{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 机器学习练习-决策树\n",
    "\n",
    "实验要求：1，请将本实验中两处代码不完整的地方补充完整：2，如果出现graphviz问题，请尝试解决；3，对照本章ppt和本实验代码，理解决策树原理。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1．分类决策树模型是表示基于特征对实例进行分类的树形结构。决策树可以转换成一个**if-then**规则的集合，也可以看作是定义在特征空间划分上的类的条件概率分布。\n",
    "\n",
    "2．决策树学习旨在构建一个与训练数据拟合很好，并且复杂度小的决策树。因为从可能的决策树中直接选取最优决策树是NP完全问题。现实中采用启发式方法学习次优的决策树。\n",
    "\n",
    "决策树学习算法包括3部分：特征选择、树的生成和树的剪枝。常用的算法有ID3、\n",
    "C4.5和CART。\n",
    "\n",
    "3．特征选择的目的在于选取对训练数据能够分类的特征。特征选择的关键是其准则。常用的准则如下：\n",
    "\n",
    "（1）样本集合$D$对特征$A$的信息增益（ID3）\n",
    "\n",
    "\n",
    "$$g(D, A)=H(D)-H(D|A)$$\n",
    "\n",
    "$$H(D)=-\\sum_{k=1}^{K} \\frac{\\left|C_{k}\\right|}{|D|} \\log _{2} \\frac{\\left|C_{k}\\right|}{|D|}$$\n",
    "\n",
    "$$H(D | A)=\\sum_{i=1}^{n} \\frac{\\left|D_{i}\\right|}{|D|} H\\left(D_{i}\\right)$$\n",
    "\n",
    "其中，$H(D)$是数据集$D$的熵，$H(D_i)$是数据集$D_i$的熵，$H(D|A)$是数据集$D$对特征$A$的条件熵。\t$D_i$是$D$中特征$A$取第$i$个值的样本子集，$C_k$是$D$中属于第$k$类的样本子集。$n$是特征$A$取 值的个数，$K$是类的个数。\n",
    "\n",
    "（2）样本集合$D$对特征$A$的信息增益比（C4.5）\n",
    "\n",
    "\n",
    "$$g_{R}(D, A)=\\frac{g(D, A)}{H(D)}$$\n",
    "\n",
    "\n",
    "其中，$g(D,A)$是信息增益，$H(D)$是数据集$D$的熵。\n",
    "\n",
    "（3）样本集合$D$的基尼指数（CART）\n",
    "\n",
    "$$\\operatorname{Gini}(D)=1-\\sum_{k=1}^{K}\\left(\\frac{\\left|C_{k}\\right|}{|D|}\\right)^{2}$$\n",
    "\n",
    "特征$A$条件下集合$D$的基尼指数：\n",
    "\n",
    " $$\\operatorname{Gini}(D, A)=\\frac{\\left|D_{1}\\right|}{|D|} \\operatorname{Gini}\\left(D_{1}\\right)+\\frac{\\left|D_{2}\\right|}{|D|} \\operatorname{Gini}\\left(D_{2}\\right)$$\n",
    " \n",
    "4．决策树的生成。通常使用信息增益最大、信息增益比最大或基尼指数最小作为特征选择的准则。决策树的生成往往通过计算信息增益或其他指标，从根结点开始，递归地产生决策树。这相当于用信息增益或其他准则不断地选取局部最优的特征，或将训练集分割为能够基本正确分类的子集。\n",
    "\n",
    "5．决策树的剪枝。由于生成的决策树存在过拟合问题，需要对它进行剪枝，以简化学到的决策树。决策树的剪枝，往往从已生成的树上剪掉一些叶结点或叶结点以上的子树，并将其父结点或根结点作为新的叶结点，从而简化生成的决策树。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "from math import log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Looking in indexes: https://mirrors.aliyun.com/pypi/simple\n",
      "Requirement already satisfied: graphviz in c:\\users\\12309\\appdata\\roaming\\python\\python311\\site-packages (0.20.3)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install graphviz -i https://mirrors.aliyun.com/pypi/simple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Looking in indexes: https://mirrors.aliyun.com/pypi/simple\n",
      "Requirement already satisfied: scikit-learn in c:\\programdata\\anaconda3\\lib\\site-packages (1.2.2)\n",
      "Requirement already satisfied: numpy>=1.17.3 in c:\\programdata\\anaconda3\\lib\\site-packages (from scikit-learn) (1.24.3)\n",
      "Requirement already satisfied: scipy>=1.3.2 in c:\\programdata\\anaconda3\\lib\\site-packages (from scikit-learn) (1.10.1)\n",
      "Requirement already satisfied: joblib>=1.1.1 in c:\\programdata\\anaconda3\\lib\\site-packages (from scikit-learn) (1.2.0)\n",
      "Requirement already satisfied: threadpoolctl>=2.0.0 in c:\\programdata\\anaconda3\\lib\\site-packages (from scikit-learn) (2.2.0)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install scikit-learn -i https://mirrors.aliyun.com/pypi/simple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 创建数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_data():\n",
    "    datasets = [['青年', '否', '否', '一般', '否'],\n",
    "               ['青年', '否', '否', '好', '否'],\n",
    "               ['青年', '是', '否', '好', '是'],\n",
    "               ['青年', '是', '是', '一般', '是'],\n",
    "               ['青年', '否', '否', '一般', '否'],\n",
    "               ['中年', '否', '否', '一般', '否'],\n",
    "               ['中年', '否', '否', '好', '否'],\n",
    "               ['中年', '是', '是', '好', '是'],\n",
    "               ['中年', '否', '是', '非常好', '是'],\n",
    "               ['中年', '否', '是', '非常好', '是'],\n",
    "               ['老年', '否', '是', '非常好', '是'],\n",
    "               ['老年', '否', '是', '好', '是'],\n",
    "               ['老年', '是', '否', '好', '是'],\n",
    "               ['老年', '是', '否', '非常好', '是'],\n",
    "               ['老年', '否', '否', '一般', '否'],\n",
    "               ]\n",
    "    labels = [u'年龄', u'有工作', u'有自己的房子', u'信贷情况', u'类别']\n",
    "    # 返回数据集和每个维度的名称\n",
    "    return datasets, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets, labels = create_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = pd.DataFrame(datasets, columns=labels) #请将本行代码补充完整"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>年龄</th>\n",
       "      <th>有工作</th>\n",
       "      <th>有自己的房子</th>\n",
       "      <th>信贷情况</th>\n",
       "      <th>类别</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>青年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>青年</td>\n",
       "      <td>是</td>\n",
       "      <td>是</td>\n",
       "      <td>一般</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>中年</td>\n",
       "      <td>是</td>\n",
       "      <td>是</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>老年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>老年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    年龄 有工作 有自己的房子 信贷情况 类别\n",
       "0   青年   否      否   一般  否\n",
       "1   青年   否      否    好  否\n",
       "2   青年   是      否    好  是\n",
       "3   青年   是      是   一般  是\n",
       "4   青年   否      否   一般  否\n",
       "5   中年   否      否   一般  否\n",
       "6   中年   否      否    好  否\n",
       "7   中年   是      是    好  是\n",
       "8   中年   否      是  非常好  是\n",
       "9   中年   否      是  非常好  是\n",
       "10  老年   否      是  非常好  是\n",
       "11  老年   否      是    好  是\n",
       "12  老年   是      否    好  是\n",
       "13  老年   是      否  非常好  是\n",
       "14  老年   否      否   一般  否"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 熵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算给定数据集的熵（信息熵）\n",
    "def calc_ent(datasets):\n",
    "    # 计算数据集的长度\n",
    "    data_length = len(datasets)\n",
    "    # 统计数据集中每个类别的出现次数\n",
    "    label_count = {}\n",
    "    for i in range(data_length):\n",
    "        # 获取每个样本的标签\n",
    "        label = datasets[i][-1]\n",
    "        # 如果该类别不在label_count中，则添加到label_count中\n",
    "        if label not in label_count:\n",
    "            label_count[label] = 0\n",
    "        # 统计该类别的出现次数\n",
    "        label_count[label] += 1\n",
    "    # 计算熵\n",
    "    ent = -sum([(p / data_length) * log(p / data_length, 2)\n",
    "                for p in label_count.values()])\n",
    "    return ent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 条件熵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算给定数据集在指定特征上的条件熵\n",
    "def cond_ent(datasets, axis=0):\n",
    "    # 计算数据集的长度\n",
    "    data_length = len(datasets)\n",
    "    # 使用字典feature_sets存储在指定特征上的不同取值对应的样本集合\n",
    "    feature_sets = {}\n",
    "    for i in range(data_length):\n",
    "        # 获取每个样本在指定特征上的取值\n",
    "        feature = datasets[i][axis]\n",
    "        # 如果该取值不在feature_sets中，则添加到feature_sets中\n",
    "        if feature not in feature_sets:\n",
    "            feature_sets[feature] = []\n",
    "        # 将该样本添加到对应取值的样本集合中\n",
    "        feature_sets[feature].append(datasets[i])\n",
    "    # 计算条件熵\n",
    "    cond_ent = sum([(len(p) / data_length) * calc_ent(p)\n",
    "                    for p in feature_sets.values()])\n",
    "    return cond_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9709505944546686"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_ent(datasets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 信息增益"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算信息增益\n",
    "def info_gain(ent, cond_ent):\n",
    "    # 信息增益等于熵减去条件熵\n",
    "    return ent - cond_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用信息增益选择最佳特征作为根节点特征进行决策树的训练\n",
    "def info_gain_train(datasets):\n",
    "    # 计算特征的数量\n",
    "    count = len(datasets[0]) - 1\n",
    "    # 计算整个数据集的熵\n",
    "    ent = calc_ent(datasets)\n",
    "    # 存储每个特征的信息增益\n",
    "    best_feature = []\n",
    "    for c in range(count):\n",
    "        # 计算每个特征的条件熵\n",
    "        c_info_gain = info_gain(ent, cond_ent(datasets, axis=c))\n",
    "        # 将特征及其对应的信息增益存入best_feature列表中\n",
    "        best_feature.append((c, c_info_gain))\n",
    "        # 输出每个特征的信息增益\n",
    "        print('特征({}) 的信息增益为： {:.3f}'.format(labels[c], c_info_gain))\n",
    "    # 找到信息增益最大的特征\n",
    "    best_ = max(best_feature, key=lambda x: x[-1])\n",
    "    # 返回信息增益最大的特征作为根节点特征\n",
    "    return '特征({})的信息增益最大，选择为根节点特征'.format(labels[best_[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征(年龄) 的信息增益为： 0.083\n",
      "特征(有工作) 的信息增益为： 0.324\n",
      "特征(有自己的房子) 的信息增益为： 0.420\n",
      "特征(信贷情况) 的信息增益为： 0.363\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'特征(有自己的房子)的信息增益最大，选择为根节点特征'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "info_gain_train(np.array(datasets))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 利用ID3算法生成决策树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义节点类 二叉树\n",
    "class Node:\n",
    "    def __init__(self, root=True, label=None, feature_name=None, feature=None):\n",
    "        self.root = root\n",
    "        self.label = label\n",
    "        self.feature_name = feature_name\n",
    "        self.feature = feature\n",
    "        self.tree = {}\n",
    "        self.result = {\n",
    "            'label:': self.label,\n",
    "            'feature': self.feature,\n",
    "            'tree': self.tree\n",
    "        }\n",
    "\n",
    "    def __repr__(self):\n",
    "        return '{}'.format(self.result)\n",
    "\n",
    "    def add_node(self, val, node):\n",
    "        self.tree[val] = node\n",
    "\n",
    "    def predict(self, features):\n",
    "        if self.root is True:\n",
    "            return self.label\n",
    "        return self.tree[features[self.feature]].predict(features)\n",
    "\n",
    "\n",
    "class DTree:\n",
    "    def __init__(self, epsilon=0.1):\n",
    "        self.epsilon = epsilon\n",
    "        self._tree = {}\n",
    "\n",
    "    # 熵\n",
    "    @staticmethod\n",
    "    def calc_ent(datasets):\n",
    "        data_length = len(datasets)\n",
    "        label_count = {}\n",
    "        for i in range(data_length):\n",
    "            label = datasets[i][-1]\n",
    "            if label not in label_count:\n",
    "                label_count[label] = 0\n",
    "            label_count[label] += 1\n",
    "        ent = -sum([(p / data_length) * log(p / data_length, 2)\n",
    "                    for p in label_count.values()])\n",
    "        return ent\n",
    "\n",
    "    # 经验条件熵\n",
    "    def cond_ent(self, datasets, axis=0):\n",
    "        data_length = len(datasets)\n",
    "        feature_sets = {}\n",
    "        for i in range(data_length):\n",
    "            feature = datasets[i][axis]\n",
    "            if feature not in feature_sets:\n",
    "                feature_sets[feature] = []\n",
    "            feature_sets[feature].append(datasets[i])\n",
    "        cond_ent = sum([(len(p) / data_length) * self.calc_ent(p)\n",
    "                        for p in feature_sets.values()])\n",
    "        return cond_ent\n",
    "\n",
    "    # 信息增益\n",
    "    @staticmethod\n",
    "    def info_gain(ent, cond_ent):\n",
    "        return ent - cond_ent\n",
    "\n",
    "    def info_gain_train(self, datasets):\n",
    "        count = len(datasets[0]) - 1\n",
    "        ent = self.calc_ent(datasets)\n",
    "        best_feature = []\n",
    "        for c in range(count):\n",
    "            c_info_gain = self.info_gain(ent, self.cond_ent(datasets, axis=c))\n",
    "            best_feature.append((c, c_info_gain))\n",
    "        # 比较大小\n",
    "        best_ = max(best_feature, key=lambda x: x[-1])\n",
    "        return best_\n",
    "\n",
    "    def train(self, train_data):\n",
    "        \"\"\"\n",
    "        input:数据集D(DataFrame格式)，特征集A，阈值eta\n",
    "        output:决策树T\n",
    "        \"\"\"\n",
    "        _, y_train, features = train_data.iloc[:, :\n",
    "                                               -1], train_data.iloc[:,\n",
    "                                                                    -1], train_data.columns[:\n",
    "                                                                                            -1]\n",
    "        # 1,若D中实例属于同一类Ck，则T为单节点树，并将类Ck作为结点的类标记，返回T\n",
    "        if len(y_train.value_counts()) == 1:\n",
    "            return Node(root=True, label=y_train.iloc[0])\n",
    "\n",
    "        # 2, 若A为空，则T为单节点树，将D中实例树最大的类Ck作为该节点的类标记，返回T\n",
    "        if len(features) == 0:\n",
    "            return Node(\n",
    "                root=True,\n",
    "                label=y_train.value_counts().sort_values(\n",
    "                    ascending=False).index[0])\n",
    "\n",
    "        # 3,计算最大信息增益 同5.1,Ag为信息增益最大的特征\n",
    "        max_feature, max_info_gain = self.info_gain_train(np.array(train_data))\n",
    "        max_feature_name = features[max_feature]\n",
    "\n",
    "        # 4,Ag的信息增益小于阈值eta,则置T为单节点树，并将D中是实例数最大的类Ck作为该节点的类标记，返回T\n",
    "        if max_info_gain < self.epsilon:\n",
    "            return Node(\n",
    "                root=True,\n",
    "                label=y_train.value_counts().sort_values(\n",
    "                    ascending=False).index[0])\n",
    "\n",
    "        # 5,构建Ag子集\n",
    "        node_tree = Node(\n",
    "            root=False, feature_name=max_feature_name, feature=max_feature)\n",
    "\n",
    "        feature_list = train_data[max_feature_name].value_counts().index\n",
    "        for f in feature_list:\n",
    "            sub_train_df = train_data.loc[train_data[max_feature_name] ==\n",
    "                                          f].drop([max_feature_name], axis=1)\n",
    "\n",
    "            # 6, 递归生成树\n",
    "            sub_tree = self.train(sub_train_df)\n",
    "            node_tree.add_node(f, sub_tree)\n",
    "\n",
    "        # pprint.pprint(node_tree.tree)\n",
    "        return node_tree\n",
    "\n",
    "    def fit(self, train_data):\n",
    "        self._tree = self.train(train_data)\n",
    "        return self._tree\n",
    "\n",
    "    def predict(self, X_test):\n",
    "        return self._tree.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets, labels = create_data()\n",
    "data_df = pd.DataFrame(datasets, columns=labels)\n",
    "dt = DTree()\n",
    "tree = dt.fit(data_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'label:': None, 'feature': 2, 'tree': {'否': {'label:': None, 'feature': 1, 'tree': {'否': {'label:': '否', 'feature': None, 'tree': {}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'否'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.predict(['老年', '否', '否', '一般'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scikit-learn实例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用Iris数据集，我们可以构建如下树："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'load_iris' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[10], line 14\u001b[0m\n\u001b[0;32m     10\u001b[0m     \u001b[38;5;66;03m# print(data)\u001b[39;00m\n\u001b[0;32m     11\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m data[:, :\u001b[38;5;241m2\u001b[39m], data[:, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m],iris\u001b[38;5;241m.\u001b[39mfeature_names[\u001b[38;5;241m0\u001b[39m:\u001b[38;5;241m2\u001b[39m]\n\u001b[1;32m---> 14\u001b[0m X, y,feature_name\u001b[38;5;241m=\u001b[39m create_data()\n\u001b[0;32m     15\u001b[0m X_train, X_test, y_train, y_test \u001b[38;5;241m=\u001b[39m train_test_split(X, y, test_size\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.3\u001b[39m)\n",
      "Cell \u001b[1;32mIn[10], line 3\u001b[0m, in \u001b[0;36mcreate_data\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcreate_data\u001b[39m():\n\u001b[1;32m----> 3\u001b[0m     iris \u001b[38;5;241m=\u001b[39m load_iris () \u001b[38;5;66;03m#请将本行代码补充完整       \u001b[39;00m\n\u001b[0;32m      4\u001b[0m     df \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame(iris\u001b[38;5;241m.\u001b[39mdata, columns\u001b[38;5;241m=\u001b[39miris\u001b[38;5;241m.\u001b[39mfeature_names)\n\u001b[0;32m      5\u001b[0m     df[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlabel\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m iris\u001b[38;5;241m.\u001b[39mtarget\n",
      "\u001b[1;31mNameError\u001b[0m: name 'load_iris' is not defined"
     ]
    }
   ],
   "source": [
    "# data\n",
    "def create_data():\n",
    "    iris = load_iris () #请将本行代码补充完整       \n",
    "    df = pd.DataFrame(iris.data, columns=iris.feature_names)\n",
    "    df['label'] = iris.target\n",
    "    df.columns = [\n",
    "        'sepal length', 'sepal width', 'petal length', 'petal width', 'label'\n",
    "    ]\n",
    "    data = np.array(df.iloc[:100, [0, 1, -1]])\n",
    "    # print(data)\n",
    "    return data[:, :2], data[:, -1],iris.feature_names[0:2]\n",
    "\n",
    "\n",
    "X, y,feature_name= create_data()\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9333333333333333"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.tree import export_graphviz\n",
    "import graphviz\n",
    "from sklearn import tree\n",
    "\n",
    "clf = DecisionTreeClassifier()\n",
    "clf.fit(X_train, y_train,)\n",
    "\n",
    "clf.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一旦经过训练，就可以用 plot_tree函数绘制树："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0.5, 0.9, 'x[0] <= 5.45\\ngini = 0.5\\nsamples = 70\\nvalue = [35, 35]'),\n",
       " Text(0.25, 0.7, 'x[1] <= 2.8\\ngini = 0.272\\nsamples = 37\\nvalue = [31, 6]'),\n",
       " Text(0.375, 0.8, 'True  '),\n",
       " Text(0.125, 0.5, 'gini = 0.0\\nsamples = 5\\nvalue = [0, 5]'),\n",
       " Text(0.375, 0.5, 'x[0] <= 5.3\\ngini = 0.061\\nsamples = 32\\nvalue = [31, 1]'),\n",
       " Text(0.25, 0.3, 'gini = 0.0\\nsamples = 29\\nvalue = [29, 0]'),\n",
       " Text(0.5, 0.3, 'x[1] <= 3.2\\ngini = 0.444\\nsamples = 3\\nvalue = [2, 1]'),\n",
       " Text(0.375, 0.1, 'gini = 0.0\\nsamples = 1\\nvalue = [0, 1]'),\n",
       " Text(0.625, 0.1, 'gini = 0.0\\nsamples = 2\\nvalue = [2, 0]'),\n",
       " Text(0.75, 0.7, 'x[1] <= 3.4\\ngini = 0.213\\nsamples = 33\\nvalue = [4, 29]'),\n",
       " Text(0.625, 0.8, '  False'),\n",
       " Text(0.625, 0.5, 'gini = 0.0\\nsamples = 29\\nvalue = [0, 29]'),\n",
       " Text(0.875, 0.5, 'gini = 0.0\\nsamples = 4\\nvalue = [4, 0]')]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tree.plot_tree(clf) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以导出树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "tree_pic = export_graphviz(clf, out_file=\"mytree.pdf\")\n",
    "with open('mytree.pdf') as f:\n",
    "    dot_graph = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 12.2.1 (20241206.2353)\n",
       " -->\n",
       "<!-- Title: Tree Pages: 1 -->\n",
       "<svg width=\"454pt\" height=\"491pt\"\n",
       " viewBox=\"0.00 0.00 454.00 491.25\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 487.25)\">\n",
       "<title>Tree</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-487.25 450,-487.25 450,4 -4,4\"/>\n",
       "<!-- 0 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>0</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"277.5,-483.25 168.5,-483.25 168.5,-412.25 277.5,-412.25 277.5,-483.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-465.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[0] &lt;= 5.45</text>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-450.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.5</text>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-434.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 70</text>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-418.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [35, 35]</text>\n",
       "</g>\n",
       "<!-- 1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>1</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"213.75,-376.25 112.25,-376.25 112.25,-305.25 213.75,-305.25 213.75,-376.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-358.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 2.8</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-343.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.272</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-327.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 37</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-311.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [31, 6]</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;1 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>0&#45;&gt;1</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M203.02,-411.79C198.37,-403.64 193.35,-394.86 188.49,-386.36\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"191.64,-384.82 183.64,-377.87 185.57,-388.29 191.64,-384.82\"/>\n",
       "<text text-anchor=\"middle\" x=\"176.31\" y=\"-395.25\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">True</text>\n",
       "</g>\n",
       "<!-- 8 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>8</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"333.75,-376.25 232.25,-376.25 232.25,-305.25 333.75,-305.25 333.75,-376.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-358.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 3.4</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-343.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.213</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-327.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 33</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-311.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [4, 29]</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;8 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>0&#45;&gt;8</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M242.98,-411.79C247.63,-403.64 252.65,-394.86 257.51,-386.36\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"260.43,-388.29 262.36,-377.87 254.36,-384.82 260.43,-388.29\"/>\n",
       "<text text-anchor=\"middle\" x=\"269.69\" y=\"-395.25\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">False</text>\n",
       "</g>\n",
       "<!-- 2 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>2</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"94,-261.38 0,-261.38 0,-206.12 94,-206.12 94,-261.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-244.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-228.32\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 5</text>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-212.57\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 5]</text>\n",
       "</g>\n",
       "<!-- 1&#45;&gt;2 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>1&#45;&gt;2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M124.37,-304.79C111.74,-293.35 97.71,-280.65 85.11,-269.25\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"87.54,-266.72 77.77,-262.61 82.84,-271.91 87.54,-266.72\"/>\n",
       "</g>\n",
       "<!-- 3 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>3</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"213.75,-269.25 112.25,-269.25 112.25,-198.25 213.75,-198.25 213.75,-269.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-251.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[0] &lt;= 5.3</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-236.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.061</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-220.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 32</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-204.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [31, 1]</text>\n",
       "</g>\n",
       "<!-- 1&#45;&gt;3 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>1&#45;&gt;3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M163,-304.79C163,-297.17 163,-289 163,-281.02\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"166.5,-281.07 163,-271.07 159.5,-281.07 166.5,-281.07\"/>\n",
       "</g>\n",
       "<!-- 4 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>4</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"155.75,-154.38 54.25,-154.38 54.25,-99.12 155.75,-99.12 155.75,-154.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"105\" y=\"-137.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"105\" y=\"-121.33\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 29</text>\n",
       "<text text-anchor=\"middle\" x=\"105\" y=\"-105.58\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [29, 0]</text>\n",
       "</g>\n",
       "<!-- 3&#45;&gt;4 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>3&#45;&gt;4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M143.69,-197.79C137.79,-187.12 131.3,-175.36 125.34,-164.57\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"128.46,-162.98 120.56,-155.91 122.33,-166.36 128.46,-162.98\"/>\n",
       "</g>\n",
       "<!-- 5 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>5</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"268,-162.25 174,-162.25 174,-91.25 268,-91.25 268,-162.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-144.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 3.2</text>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-129.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.444</text>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-113.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 3</text>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-97.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [2, 1]</text>\n",
       "</g>\n",
       "<!-- 3&#45;&gt;5 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>3&#45;&gt;5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M182.31,-197.79C186.76,-189.73 191.56,-181.05 196.21,-172.63\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"199.27,-174.33 201.04,-163.89 193.14,-170.95 199.27,-174.33\"/>\n",
       "</g>\n",
       "<!-- 6 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>6</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"212,-55.25 118,-55.25 118,0 212,0 212,-55.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"165\" y=\"-37.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"165\" y=\"-22.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 1</text>\n",
       "<text text-anchor=\"middle\" x=\"165\" y=\"-6.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 1]</text>\n",
       "</g>\n",
       "<!-- 5&#45;&gt;6 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>5&#45;&gt;6</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M200.94,-90.96C196.17,-82.68 191.06,-73.81 186.23,-65.45\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"189.31,-63.78 181.28,-56.87 183.25,-67.28 189.31,-63.78\"/>\n",
       "</g>\n",
       "<!-- 7 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>7</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"324,-55.25 230,-55.25 230,0 324,0 324,-55.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"277\" y=\"-37.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"277\" y=\"-22.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 2</text>\n",
       "<text text-anchor=\"middle\" x=\"277\" y=\"-6.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [2, 0]</text>\n",
       "</g>\n",
       "<!-- 5&#45;&gt;7 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>5&#45;&gt;7</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M241.06,-90.96C245.83,-82.68 250.94,-73.81 255.77,-65.45\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"258.75,-67.28 260.72,-56.87 252.69,-63.78 258.75,-67.28\"/>\n",
       "</g>\n",
       "<!-- 9 -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>9</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"333.75,-261.38 232.25,-261.38 232.25,-206.12 333.75,-206.12 333.75,-261.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-244.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-228.32\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 29</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-212.57\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 29]</text>\n",
       "</g>\n",
       "<!-- 8&#45;&gt;9 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>8&#45;&gt;9</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M283,-304.79C283,-294.56 283,-283.32 283,-272.91\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"286.5,-273.1 283,-263.1 279.5,-273.1 286.5,-273.1\"/>\n",
       "</g>\n",
       "<!-- 10 -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>10</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"446,-261.38 352,-261.38 352,-206.12 446,-206.12 446,-261.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"399\" y=\"-244.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"399\" y=\"-228.32\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 4</text>\n",
       "<text text-anchor=\"middle\" x=\"399\" y=\"-212.57\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [4, 0]</text>\n",
       "</g>\n",
       "<!-- 8&#45;&gt;10 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>8&#45;&gt;10</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M321.63,-304.79C334.26,-293.35 348.29,-280.65 360.89,-269.25\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"363.16,-271.91 368.23,-262.61 358.46,-266.72 363.16,-271.91\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.sources.Source at 0x1eeb3be7cd0>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "graphviz.Source(dot_graph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树回归"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a random dataset\n",
    "rng = np.random.RandomState(1)\n",
    "X = np.sort(5 * rng.rand(80, 1), axis=0)\n",
    "y = np.sin(X).ravel()\n",
    "y[::5] += 3 * (0.5 - rng.rand(16))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB6gUlEQVR4nO2dB5gT5dqGn2Qrdem9Sa+KgCKogNIXFTsdQY/tiA2EH46KB8uxF7B3RBDFAii9gwUQQRQLHaR3WPqWJP/1ftnJTrLZkk2bmTz3dWWTmcxMJpPZ+Z55q83lcrlACCGEEBKD2KO9A4QQQggh0YJCiBBCCCExC4UQIYQQQmIWCiFCCCGExCwUQoQQQgiJWSiECCGEEBKzUAgRQgghJGahECKEEEJIzEIhRAghhJCYhUKIkBhg586dsNlsmDhxYkDrderUST0I8YecT3JeyflFiFmhECIkggOG9khOTka1atXQvXt3TJgwAadOnYr2LhqGOnXqeB2rvB6BirpQsmzZMq99iYuLQ6VKlXDzzTfj77//jtp+EUICx8ZeY4SEHxm0hw4diieffBIXXHABMjMzceDAATWgLly4ELVq1cK3336LCy+8MCyfL//m6enpSEhIUIN2YcnIyFDPiYmJiBQzZszA6dOnPdNz5szB1KlT8eqrr6JChQqe+e3bt0fdunURDeR3u+qqq/DAAw/gkksuUb/n77//jnfeeQclSpTAH3/8gSpVqsDqOBwO9d2TkpKUICTEjMRHewcIiSV69uyJNm3aeKbHjBmDJUuW4JprrsF1112nrAnFihUL+edqVqhAiaQA0rj++uu9pkUwihCS+WItyoszZ84oERJJrrzySmUF0mjUqBHuvfdeTJo0CaNGjYrovpw9exbFixeP6GeKqA5EWBNiROgaIyTKXH311Xj88cfxzz//YPLkyV7vbdy4UQ205cqVU0JGRJRYjnw5ceIEHn74YSUU5O68Ro0aGDx4MI4cOZJnjJAIDLFSybKyTtWqVdG7d2+veA9/MUKHDh3CHXfcgcqVK6t9uuiii/DJJ594LaN93ksvvYT33nsP9erVU58h1pM1a9YEfcyGDBmCkiVLYtu2bUhNTUWpUqUwYMAA9Z7T6cRrr72GZs2aqf2T/bz77rtx/PjxXNuZO3euEjMioGQbvXr1wp9//lnk/ZJtCbJfevbu3Yvbb79d7YscB9m3jz76KNf6cg6IIJb9EVeb/Kbz589Xx1KsUBrymzRv3hxr165Fhw4dlAD6z3/+o94Ty98TTzyB+vXrq8+qWbOmEmUyX49YIq+44gqUKVNGHUsRcdo2NF5//XW1r7L9smXLqvPvs88+KzBG6K233lLryeeLC/i+++5T56ge7Tv89ddfyromn1G9enW88MILRTjyhBQdWoQIMQCDBg1Sg9CCBQtw5513qnkyIF9++eVqcBg9erQaHKdNm6YsI19//TVuuOEGtZy4kWQAFmuSDLatWrVSAkgE0549e7zcSXpuuukm9Rn333+/ElAicGRw3LVrV56Wl3PnzqkBbOvWrRg2bJhy83355ZdKmMhA9+CDD3otL4OmxD+JEJEBUwa5G2+8Edu3b1duumDIyspSMVYymIvg0qwh8lmaK1JcVzt27MAbb7yBX3/9FT/++KPncz/99FPcdtttahvPP/+8sqi8/fbbanuybH7Wp7zQBIGIBo2DBw/isssuU99fjlnFihWVABMxefLkSTz00EMei5aI4v3796vjKK41OX5Lly71+1lHjx5VFsa+ffti4MCBSmSJCBQh9cMPP+Cuu+5CkyZNsGHDBuVW3Lx5s3I7CvK7ixVSXLHirhXBIr+pHB+N999/Xx0/EeKyP+fPn1fuv9WrV6N///55HoP//ve/GDduHLp06aKsY5s2bVLHVQSw/vgLIk579Oihzolbb70VX331Ff7v//4PLVq0UN+NkIggMUKEkPDy8ccfSyyea82aNXkuk5KS4rr44os90507d3a1aNHCdf78ec88p9Ppat++vatBgwaeeWPHjlXb/uabb3JtU5YXduzYoZaR/RCOHz+upl988cV897tjx47qofHaa6+p9SZPnuyZl5GR4WrXrp2rZMmSrpMnT3p9Xvny5V3Hjh3zLDtz5kw1/7vvvnMVFtlHWUe2qXHbbbepeaNHj/Za9vvvv1fzp0yZ4jV/3rx5XvNPnTrlKlOmjOvOO+/0Wu7AgQPqd/Cd78vSpUvV9j766CPX4cOHXfv27VOfUb9+fZfNZnP9/PPPnmXvuOMOV9WqVV1Hjhzx2kbfvn3VZ509e1ZNv/zyy2qbM2bM8Cxz7tw5V+PGjdV8+UwN+U1k3jvvvOO1zU8//dRlt9vVcdAjy8nyP/74o5p+9dVX1bTse1707t3b1axZs0Kd19pvc+jQIVdiYqKrW7duLofD4VnujTfe8Bwv3+8wadIkz7z09HRXlSpVXDfddFO+n0tIKKFrjBCDIO4JLXvs2LFjKnZI7pJlnlh45CFWALFgbNmyRblbBLEOiXtKsxDpySuAVeKQJP5H3C3+XEZ5IYHLYqno16+fZ57c4YvlQCxTy5cv91q+T58+XtYRzXUkFqFQIBYHPWKdSklJQdeuXT3HTB6tW7dWx1ezrojlSyxY8j30y0m8S9u2bfO0wvgiFjix8Ij7RywbaWlpytIkLkAtSF1+n2uvvVa91n+W/I6y/Lp169Sy8+bNU9Y/sehoiGtPsxD6IlYcsXr5fn+xAjVu3Njrs8TSJGjfS9xhwsyZM5UVyR+yjFgUA3FlLlq0SAXYi5XLbs8ZXuQ7lC5dGrNnz/ZaXn4TsWZpyDl56aWXhuz8IKQw0DVGiEEQISFxIYK4KWTglNghefhDXFkycEo8iri5AkEGUXEHjRgxQrlUxHUjrhKJK8ov20liWBo0aOA1yAky+Grv65FsOD2aKApEfOVFfHy8im/SIwJRxIV2HP0dM205QRMIvsigXRjGjh2rxJ38dtOnT8fnn3/udWwOHz6sBJfESckjv32SYyexVL7iVWJ9/CG/vW8wu3wvcZGKOMvvs0SgfvDBB/jXv/6l3K6dO3dW7ilxg2n7Ly4qETYiTGQfunXrplxi4q7NC+33l3gjPbKfkuHne37I7+f7feUcERccIZGCQogQAyB33jKAa4Oedpf+yCOPKMuBP/IaIAuL3LWLpULiRiQgVwTXs88+qyxRF198MUJBXhlFoajaIWLOV5DJcRMRNGXKFL/raAJBO75ivfEn/ERkFQaJZZFYGEFityTOSKwfEmckQcra54jVQ+KR/FHUkgn+sgvl82SfXnnlFb/ryD5p665YsUJZiMRKI9aoL774QglDiVOT303ErcT3zJo1S70vli0JghbxJzFARj8/CCksFEKEGAAZkAVN9Gj1ccTtpA20eSFWBKlbUxRkXbEKyUOsCS1btsTLL7+cK3tNo3bt2upuXQZcvQiR7Dbt/Wgi30esGGK1yK8MgSwniGgq6PgGwnPPPacsQ88884yqKSTCS7LRpN5OQZ8jx04yqEQE6K0kYh0sLPK9fvvtN2XhKaiuj/x+spw8RDj973//w6OPPqrEkbavEqAv1iN5iMtLrEby3aTsg79yDNrvLwJKX+NJ1pWg9VAea0JCBWOECIkyYoF56qmnVAaWlgIuA7RkZ7377rsqi8gXcbloiFtMBj8ZgAt7Zy2WC8kC8h1EZdD2TbPWI6nqknYv1gN99pakWUu8R8eOHRFNJKZKRIccT19kP7UUbhGc4v6SwV8KAuZ3fANBjqH8HpK1JsdJLB4yLdYUf2JV/zmyTxL3pS+PIL+RZG8F8v1lG/7WkYw/yUzTYtB8EREsaL+/xKP5ureaNm2qzil/x0wQoSPLSbV0/bn34YcfKounlCcgxGjQIkRIBJG0abGeyKAsadUigiRwV+6kZQDU32W/+eabysUirg5xt8gdtqyzcuVK5UoT8SOMHDlSpR3fcsstKnhXAoNloJPtiVVCAql9kVRqsQTIwCmDm7iCREjJ9iUdOy8kJVvEmaTLSw0bSTGXz5a0aKndI0IqmogQk/R5cfGtX79exbWIVU2sXRJIPH78eBUHIyJIUrqlbIGUG5DvLNYbKR0griKxKEnKfVGQ30PKHMjxEAuRPMTKIkHY8jvK8ZbfR4KkxXqliRLZb/lMCeCWdHWp6yQuPu2cKEzlZvk+8tn33HOP+kz5HiIM5ZyT+eIClVpAkjIvrjERJnLuSeyQuL0kZkfOOUGOnbgNZRsSRyaxR7J/sk5ev7McQ7EWietMgscl8FusQ7JtCSDXB0YTYhhCmoNGCMk3zVh7SIqxpAl37drVNX78eE/auS/btm1zDR48WC2bkJDgql69uuuaa65xffXVV17LHT161DVs2DD1vmy7Ro0aKsVcS9n2TZ+X+ffdd59KzS5RooRK427btq1r2rRp+abPCwcPHnQNHTrUVaFCBfVZkuKvbVdD+zx/6fky/4knngg6fV72Oy/ee+89V+vWrV3FihVzlSpVSu3jqFGjVJq7HklJ7969u/r+ycnJrnr16rmGDBni+uWXXwqVPv/ll1/6fb9Tp06u0qVLu06cOOE5ZnK8a9asqX5H+T2lPILsp57t27e7evXqpfa7YsWKrhEjRri+/vpr9VmrVq3yLCe/SV6p7VLO4Pnnn1fvJyUlucqWLauOxbhx41xpaWlqmcWLF6v0+GrVqqnfUJ779evn2rx5s2c77777rqtDhw6qBIJsR47NyJEjPdvwlz6vT5eXc0u+a+XKlV333nuvKtmgJ6/vIL9t7dq18z3+hIQS9hojhBADI5YlqTAtVkDJFCOEhBYKIUIIMQgSx6MP8pYYIcngE/eWuDMJIaGHMUKEEGIQJCtLai9J4LIEF0v2nsT35FUOgBASPBRChBBiECRzTAodivARK5AEVkuRRklfJ4SEB7rGCCGEEBKzsI4QIYQQQmIWCiFCCCGExCyMESoAaSWwb98+VUCsMAXNCCGEEBJ9JPLn1KlTqFatWq6+hHoohApARJDWqJAQQggh5mL37t2qanpeUAgVgFZKXg6klOUnhBBCiPE5efKkMmQU1PqHQqgANHeYiCAKIUIIIcRcFBTWwmBpQgghhMQsFEKEEEIIiVkohAghhBASszBGiBBCSFRKk2RkZER7N4iJSUhIQFxcXNDboRAihBASUUQA7dixQ4khQoKhTJkyqFKlSlB1/iiECCGERLTI3f79+9WdvKQ251fojpD8zqOzZ8/i0KFDarpq1aooKhRChBBCIkZWVpYawKTab/HixaO9O8TEFCtWTD2LGKpUqVKR3WSU4oQQQiKGw+FQz4mJidHeFWIBimeL6czMzCJvg0KIEEJIxGHvRmKU88hUQmjFihW49tprlUlVvvyMGTPyXX7ZsmVqOd/HgQMHIrbPhBBCCDEuphJCZ86cwUUXXYQ333wzoPU2bdqkgvO0h/gSifXYvHkz5s6diy1btkR7VwghMUKnTp3w0EMPRXs3SBCYKli6Z8+e6hEoInwkxY5Yk2PHjmHQwP6YM3e+Z15qz+6YPGUqypYtG9V9I4QQvZfiqquuwvHjxzkmGQhTWYSKSsuWLVVqXdeuXfHjjz/mu2x6errqWKt/EGMjImjVikWY3B/Y9RjUs0wPHNAv2rtGCCHE4FhaCIn4eeedd/D111+rh9SsEDPmunXr8lzn2WefRUpKiuch6xBju8PEEjShtwMDWgE1y0A9j7/OoebTTUaIdYm0O1zCMwYPHoySJUuq8eXll1/2ev/TTz9FmzZtUKpUKVXkr3///p46Nzt37lTWIEEs1RKvOmTIEDU9b948XHHFFcpKVL58eVxzzTXYtm1bRL4TsbgQatSoEe6++260bt0a7du3x0cffaSeX3311TzXGTNmDNLS0jyP3bt3R3SfSWBoF4sOdb3nd6znft66dWsU9ooQEm53eK/UHuoan5qaioYNG6ppcTmFk5EjR2L58uWYOXMmFixYoFxd+htrSeF+6qmn8Ntvv6lkHhE/mtiRm2q5IdfHrY4fP94jsIYPH45ffvkFixcvVkUmb7jhBlbejhCmihEKBZdeeil++OGHPN9PSkpSD2IO6tVzK54V292WII3l2TdT9evXj9KeEUIi4Q6XmyD5/39gptsdPnvOvLB85unTp/Hhhx9i8uTJ6Ny5s5r3ySefoEaNGp5lbr/9ds/runXrYsKECbjkkkvUumJFKleunN+41Ztuusnrs+SmvWLFivjrr7/QvHnzsHwfEiMWIX+sX78+qFLcxFjInaAERj8wMw6T1wK7T0A9P/htnJrfoEGDaO8iIcQC7nCxPkuPtLZt23rmibARq5TG2rVrVYmXWrVqKfdYx44d1fxdu3blu23Z5379+inxVLp0adSpU6dQ65EYtAiJqta7OqRpnwgbORnlxBO31t69ezFp0iT1/muvvYYLLrgAzZo1w/nz5/HBBx9gyZIlyqRJrINkh8md4KCp+qyxLmo+IST23OHRuAES91b37t3VY8qUKcqiI0JGpkVA5YeIp9q1a+P9999XdfLEJSaWoILWIzEohMR/qgWbCeJTFW677TZMnDhR+Vz1ClpOohEjRihxJGW4L7zwQixatMhrG8T8SOChmMPlrkouguIOoyWIEGsSLXe4fG5CQgJWr16tbrwFiUkSC5VYfjZu3IijR4/iueee8yTZyJilR2srorUZEWQdiRkSEXTllVeqefmFb5AYF0KS8SUdZ/NCxJCeUaNGqQeJDUT8UAAREivu8EVwuRzKEiQiyO0O7xK2a4DE+Nxxxx0qYFoyuyTO59FHH1WBzYKIIxE6r7/+Ou655x788ccfKnBaj1h9JFts1qxZKshbmobKjZxs77333lNhG3IzP3r06LB8B+KfmIsRIoQQYm7E7X1Zhy4YNBWo9TTUs0yH2x3+4osvKquNuLK6dOmiUt4lK1kQV5jcjH/55Zdo2rSpsgy99NJLXutXr14d48aNU0KncuXKGDZsmBJSn3/+uYovEnfYww8/rD6HRA6bKz8TC1EFFaWekKTSSxAbIYSQoiPxmhLfKfGbycnJQW2L7nByPp/zqbDjt6lcY4QQQogG3eEkFNA1RgghhJCYhUKIEEIIITELXWOEEGJgJD1baucwDoaQ8ECLECGEGJBo9dMiJNagRYgQQgzaT2v194sw6c4EXFYbWPUP8Pj8ZfjXPbdi0qefBbStxLiSSIgrFrZ9JcTMUAgRQogB3WELFi/A2981xvkKxbAse/6j98jfY/jsjx4BbS/enoyr6zyL2mU6hGN3CTE1dI0RQojBUDFBF5WEq0JorDhZzvPYemxOSLZFiNWgRYgQQgyG9LWKT7R5psucOYcyZ85j1wngl91At+7dVcuHgnA407H75I/qtdOVFdZ9JsSsUAgRQojBkMDoSy+RjqIn1XTFncexZ+4BjPo2TrWSuGHk24XaztnMw5iywe1Gc4FNBKyOtPh46KGHcOLEibB/1pAhQ9TnzJgxA2aHrjFCCDEgw0eM8Lx+fomriP209Jd4CiESODt37lSNYtevXx/Wz/ntt9/Qr18/1KxZUzWjbdKkCcaPH49IQIsQIYQYkOIlinteDx1yOyb8Z2jAdYRsyHGv0SJEjMzatWtRqVIlTJ48WYmhn376CXfddRfi4uJUc9pwQosQIYQYEBccnteNGzcpUjFFuZPP2SCFUDB06tQJ999/v3I9lS1bVnWPf//993HmzBkMHToUpUqVUkUv586dq5Z3OBy44447VDNQsXBIPSi9hUOahTZr1kwN9vogednORx99VGhXWK1atVC8eHHccMMNOHr0aK5lZs6ciVatWqmGpHXr1sW4ceOQlZXldY68/fbb6Nmzp9pPWearr77yvC/7L1x88cVqWTkOel566SVUrVoV5cuXx3333YfMzEwUhdtvv10dn44dO6p9GDhwoDqu33zzDcINhRAhhBgQl0642GxxRdyK3iLkDMFexTaffPIJKlSogJ9//lmJonvvvRe33HIL2rdvj3Xr1qFbt24YNGgQzp49C6fTiRo1auDLL7/EX3/9hbFjx+I///kPpk2bprYlwmTKlClqmyJWRDjJ4N+1a1clCgpi9erVSmiJtUTcVldddRWefvppr2W+//57DB48GA8++KDah3fffVeJp2eeecZruccffxw33XSTck8NGDAAffv2xd9//63ek+8qLFq0CPv37/cSJkuXLlXiTZ7le8i25aFxzz33qKD+/B75IV3jy5Urh3Bjc+n/20guTp48iZSUFPWDlC5dOtq7QwiJEbYem4ulOx9Tr9vVGInmlfoGvI3zWWn49Per1euapS9Hj/oTQr6fAe/T+fPYsWOHsjSIGBCe/jINaWcjL9RSitvx2C0phVpWLCEiVkRcCPJaxoYbb7wRkyZNUvMOHDigrCMrV67EZZddlmsbIlpkGb3F5cUXX8QLL7ygxMfXX3+NDRs2KOtKQfTv31+NS7Nnz/bMk23MmzfPEyzdpUsXdO7cGWPGjPEsI66nUaNGYd++fWraZrMpwSJWIQ3Zd7EivfXWWypGSH6rX3/9FS1btvQKll62bJkSQuK+Em699VbY7XZ8/vnnavrQoUNqDM0PsaL5Q1xjYh2S7ycCM5DzKdDxmzFChBBiQFyuHGFgsxXNeG/TGf2NHCMkIujEmWjsX2Di68ILL/S8lsFfBEuLFi0888RdpgkA4c0331Rurl27duHcuXPIyMjwEhPCiBEjVObVG2+8odxqhRFBglhsxB2mp127dkoIaYiF58cff/SyAImAE/EgVitxqWnr6ZHpwgRHi2tPE0GCiEARchoS8yOPQPnjjz/Qu3dvPPHEE/mKoFBBIUQIIQaPEdILmkDwDhEyrmtMLDOBipLQfW7hSUhI8JoWa4p+nhaTJW4xsYo88sgjePnll5WwkNgfsf6IS0uPiCapJC6CYsuWLejRI7Cq4flx+vRpFRMkVitffK0nRcHf8ZDvriGWJrFAFbSPesSFJ1YsiZ167DG3RTTcUAgRQogB0Uct2ItoETJL+nxh3VNmQiwxEjv073//2zNP3Ei+SDyQWJUk3ufOO+9U7ixJHS8IWcZXVK1atcprWtxbmzZtytP9pF9v8ODBXtMSHC0kJiZ6LEmB8uSTTyoxWFj+/PNPXH311bjttttyxTGFEwohQkyG3D2qFgz16xcpk4iYzyJU1LwWps9HD/nflNih+fPnq/iVTz/9FGvWrPFkYWmuM4kn+v3331XKuMTDSLCyCBFNgOTFAw88gMsvv1xlbYkbST5H7xYTJED7mmuuUZllN998s4rfEXeZuJ70gdVffvkl2rRpgyuuuEIFcEuA9IcffqjeE9eWZJPJtiX4WyxJEndTGAJxjck+iQjq3r07hg8frmKpBLGUVaxYEeGEWWOEmIRjx46hV2oPlYabmpqqqg/L9PHjx6O9ayQMOHWurKJbhHS+MQqhiHL33Xcrl1SfPn3Qtm1bldqutw5t3LgRI0eOVAHJIoIEeX3kyBGVxVUQEtAs6fuScn7RRRdhwYIFuVxJIipmzZql3rvkkkvUOq+++ipq167ttdy4ceOUK09ioES8TZ06FU2bNlXvxcfHY8KECSrjrFq1akp0hQMJID98+LBypUmskfaQ/Q43zBorAGaNEaMgomfVikWY0NuBDnWBFduBB2a6Wy7MnuN9J0jMz1+Hp+HH3c+r151qP4kG5XsVqdnqx+svV6+rlmyDaxq+i2iTX5YPiTw2mw3Tp0/H9ddfDzPCrDFCYsgdNmfufEzuDwyQFlRwP7tcDgyaOl8FWdJNZl2LkFdhxICgRYiQgqBrjBAToAVZiiVIT8d67uetW7dGYa9IONEXQLQhztLp8yQ3Uuk5ryKE//vf/6K9e5aCFiFCTEC9em7FI+4wzSIkLM9OQikoK4TEaB0hk6TPk9x88MEHqvaQP0JZbdnF6BgKIULMgARGp/bsjgdmLlLuMLEEiQh68Ns4pPbsQreY5S1CDJaONapXrx7tXYgZKIQIMQmTp0zFwAH9VEyQhoggmU+shwjeUFaWJoT4h0KIEJMgHa8lO0wCoyUmiHWErI0+pqeoMUJsukpIwVAIEWIyRPxQAMWaRahoWWNe6zEWhBC/0G5KCCFGD5YuskXIvbbaHmOECPELhRAhhBg9WLrIlaVz4oQohAjxD4UQiVqBwLlz56p4F0JIQRahEFyqmT5veSZOnIgyZcpE5LOGDBli2mrUvlAIkYjCflmEBN50NSiLUHacEC1CpCjs3LlTnUPr168P+2fJ5/g+pAdauGGwNIkogwb2V/2ypFVETr+sRSotnP2yCPFf6M5mK3qMEFPoiZn4+OOP0aNHD890JCxc/A8hEe+XJU1DpTpyzTLuKsnjr3Oo+XSTEZKHRcirMGKgaBYhusaCoVOnTrj//vvx0EMPqVIWlStXVt3fz5w5g6FDh6JUqVKqpIW4/AWHw4E77rhDNQMtVqyYsoJLp3h9s9BmzZrhrrvu8mqlI9v56KOPCu0Kq1WrFooXL44bbrhBdbj3ZebMmWjVqpVqSFq3bl3VaT4rK8vzvs1mw9tvv61aesh+yjLSCV5D9l+4+OKL1bJyHPS89NJLqkt8+fLlcd999yEzMxPBIMKnSpUqnkckGvNSCJGIwX5ZhBS1xUYQFiEthZ7p80HzySefoEKFCvj555+VKLr33ntxyy23oH379li3bh26deuGQYMG4ezZs3A6nahRowa+/PJL/PXXXxg7diz+85//YNq0aWpbMsBPmTJFbVPEigingQMHomvXrrj99tsL3JfVq1croTVs2DDltrrqqqvw9NNPey3z/fffY/DgwXjwwQfVPrz77rtKPD3zzDNeyz3++OO46aab8Ntvv2HAgAHo27cv/v77b/WefFdh0aJF2L9/P7755hvPekuXLlXXdXmW7yHblofGPffck2e/NO3hi4gpOcaXXnqpEoSRaAFic7HRSL6cPHkSKSkpSEtLQ+nSpaO9O6a3CMldkb6DujB5LTBoqvt91schxM1Pu1/An4e/UK+vbzQJFUs0K9J2Pl5/BbKc51A2uR5ubuoehKOJWEJ27NihLA3a3f70jQNxLjO3NSPcFEsojxsaTy7UsmIJEbEi4kKQ1zI23HjjjZg0aZKad+DAAWUdWblyJS677LJc2xDRIsvoLS4vvvgiXnjhBSU+vv76a2zYsEFZVwqif//+alyaPXu2Z55sY968eThx4oSa7tKlCzp37owxY8Z4lpk8eTJGjRqFffv2eYTyPffco6xCGrLvYkV66623VIyQ/Fa//vorWrZs6RUsvWzZMiWE4uLcQv3WW2+F3W73xPUcOnRIjaH5oe+T+NRTT+Hqq69WFq4FCxbgiSeeUMfmgQceCOh8CnT8ZowQiRjsl0VIZJuuqnVNUEdIRNCZzEMwOhdeeKHntQz+IlhatGjhmSfuMk0ACG+++aayauzatUs1UM3IyPASE8KIESMwY8YMvPHGG8qtVhgRJIjFRtxhetq1a6eEkIZYeH788UcvC5AIOBEPYrUSwaGtp0emCxMcLa49TQQJIgJFyGlUqlRJPQqLWKY0xBUnbkcRivkJoVBAIUQiCvtlEVI4nCFpuupe241xhZBYZszwuQkJCV7TYk3Rz9PckOIWE6vII488gpdfflkJC4n9kUFdXFp6RDSJNVwEhcRJ6gOFg+X06dMqJkisVr6EIvYmwc/xkO+uIZYmsUAVtI950bZtW2UlSk9PR1JSEsIFhRCJKOyXRUghCZVFSEufN3AdocK6p8yEWGIkdujf//53rjhJPRIPJFYlife58847lTurSZMmBW5flvEVVatWrfKaFvfWpk2bvNxP/li1apWKJdJPi0VGSExM9FiSAuXJJ59UYrCoiFVKxoxwiiCBQohEBfbLIiQQixDT582GXN8kdmj+/PkqfuXTTz/FmjVrPFlYmutM4ol+//131KxZU8X7SLCyCBFNgOSFuIsuv/xylbXVu3dv9Tl6t5ggAdrXXHONyiy7+eabVfyOuMv++OMPr8DqL7/8Em3atMEVV1yhArglQPrDDz9U74lrS7LJZNsS/C2WJIm7KQyBuMa+++47HDx4UMUnyWcsXLgQ//vf/4ISUoWFQoiQKHIyfS/OZx2DEYm3F1MBtkVt+Emi33Q1e2339pg+H1HuvvtuFWDcp08f9fv169dPWYe09PqNGzdi5MiRSnCICBIkOFnikCRW5vnnn893+yIYJH1fAopF8Igl6bHHHlOuJI3u3btj1qxZyjIj2xNXVuPGjfGvf/3La1vjxo1TrjzZP4nzmTp1Kpo2barei4+Px4QJE9Q25HOuvPJKFSQdamTfRBg+/PDDKlNMrFivvPKKspKFG1Nlja1YsUL5WNeuXavS+KZPn15giW/5wYYPH44///xTnWxyoki0e2Fh1hgJF38enoafdud/sYs2jcpfjw61cwIYSeRYunMsth5zZwTd2nQ6UpJrFWk7k367GumONJROqoE+zWYi2uSX5UMij81mK9RYalRCkTVmKpupRJBfdNFFSjUWBjk4vXr1UvUVxNcohbBECYsJkZBo88+J5TA6248vjPYuxCzeFqFgYoSym66a556XkIhiKteYVL6UR2F55513lEqUqH0tuOyHH37Aq6++qkyGhESz59qv69eiUnYxyZ++OYwOtV2ongJ8+6e4zICr6kFN700DFm4RV5X3vGXbbahavRZ6976+wDumOXNmY/fuPV55Q7Vq1UBq6jVI9hOIuOPEYpXOnOk8A6crE3abd3YIiXD3eVg7fZ7kRsY6rWaRL1KYUR4kBoVQoEgQmvhN9YgAEstQXkianjw0CioGRYg/JB1WMkTyyoqTnmstbjyGSiilpjvv3oOBZV3YvA1483m4i05WlBMQ2HwYuP1F73lCwj/AoOd2447uH+cbeC5NbRcvXIXiCcDrN+T0eBv21l78NS/Fb4+3kxl7cSbNXQvlfNZJFI9SenMsE6o6QmZInye5+eCDD1TtIX+UK1cuZJ/joqXQ2kJIKnhqBa40ZFrEjZxgEgnvy7PPPqsCxwgpqqVHRI70TtOQIpJSJ0nSQPU91268q4Hnnv+KOu7nbUeQqw2Jv3m+rUnyEkLaZwkf3ppT0Vue5QIo9ZyklIHv+slxOVkh57NOUAhF3SIUZ+n0eZKb6tWrR3sXYgZTxQhFAilFLoFV2mP37t3R3iViIkQErVqxSFlvdj3mtuLItBSR9K0lkuIu6qr4Ybv7uV4F97NYbDT8zROkKreQX40Qfd2SQHq8JcfndHxOz3KX6yfmzhojhMSgRUg610pdAj0yLdHj/qxBghRuCnfxJmJNNOuLvpea2/Li8LK81KvnViBp53MGqIdnuiDNxkWctKwG3PeNu0emTP+8C0iKB4ZNtykrTiCtSbTP0oSUvsdbfkIqSSeEzmelBXdgSJHQx/SEpo6QsVwgdMmQUKCvZF1ULC2EpKz5nDlzvOZJkSbfviqEhALN+lKQC0vrubb9+E7UqeF+r2aKu/GsRuWK5TFoak4Tyq5drlbPg6YuCag1ifZZixfOx/3Tc8SViKD7Z9iQ2rObXyGltwidd9AiZOasMc/2DFJHSOrFiIXr8OHDqFixIutUkSILaendJueRFIosqAClZYSQ9CTRm/ElPV7S4iVwTCpniltr7969nk7A0udEGtlJp10pY75kyRJMmzbNq1svIaFCs74UxvIiAua95dJTKEtN/7oH6NjhCvz7vvtVaXsRJ/7akBSlNYl8Vp9bb8bixUu8xFbXLlflKaSS43NihOgaM3nWmMHS56WnllQo3rNnj+psTkgwSONYGf9FDMWEEPrll19UTSANKZQo3HbbbZg4caIqsihdfjUkdV5Ej1SqHD9+vPrnk0h8ps6TcKBZXx6YuUjdzefnwpLAaanweujsHx63mq+w8deGpCitSeSzFixcrETU8uXu2kUdO3bMdzteFqFCCCGpzSV9j8Ta2rVr14D2j8Re1ljJkiXV+ZeZmRntXSEmRkS1VL4O1qpoKiHUqVOnfO9qRAz5W0fKnBMSCcTCIoHREhNUkAsrJwbEFpG+a4GIqORCxgiJO/Dydm1x8PBRL7feytXePZVIcBYhu816dYRkEJMHIdHGVEKIEKMj1hepy1MYF5Y20BmxKWZSXI4QOnp2o2oH4o8x/xuFVl1tuLVlBdQvD2w9CkxbD9w86HKs/WFfBPfYeninu1u7+zwh0YRCiJAoWV+0gcmIwaJJ8VLoUfbLhWPnt+bZE+3a+6S+UHmIg+Pv7Hk3dHY/z14yCb2uHhy5nbYYobIIMX2ekPwx3q0oITGGES1Cdls8qpS8OKht/LVzhee1xEBJ122xlJEixAhZMH2eEKNAixCJSQpqgRHZO35j3rF3r/ca9p5chSxnTssZPRs2/I4XXngR97YH2mdXxt5XtiQ2V3VXgKxXv57fStsNGtTHZ59NRZs2bSLzRSyQPh+Kc8Qo6fOEGA0KIRJTFKYFRqQwsmtMSIwrgQvKZvu5/NCgUyr+fetLeHDpUbxxg7s+0Y7iNiBbCDVt2kQd6x+WLUDpJOB0BuB0SQmArbjkkktwVccO+Hr6jIgfd7OgBTeLRSeYc8Ro6fOEGA3j2eQJCaMVqEf3rgW2wIjGQGdWJDssuZQUfwRqPQ18+HPOewcPHlCC0+5yIT0LSEmG13Fft3pFVI672SxCwRdTNF76PCFGghYhYnnxI0U333rzDSxf8b2aV1ALjMiRkz5vViRF/sChI6pi+8qVK9G8UzyO4mv13qHD7u71J867l/3wBt/jjigdd3PgDFFWoVHT5wkxCua9FSWkABdYr9QeaNSoEfr17YP1P3+PkZ0Cbz4ay66xQJAiimPHjkWzZs098ypWzO4WC2Mdd9PgOT9CI4RoESLEPxRCxNJd4F+8xh2X8uaNwL/aFr2Leziwgmss70EXqFSpItq0ae2ZNspxN59FKMiig546QhRChPiDrjFi6S7w5YrlWCNqlgFSGwMPzPBuPlqYLu7hwdhZY0VD/11cWLBgIapXrQxnVmaupq/DprsD1ekWKyhGKLjzg+nzhOQPhRCxdBf4c9mtjLRGqCKOBn7m3em9MF3cw4F2hx6KzuJGQW/dku8nGWF//r0JbVq1xIm0k17HXbLGonHczUKOxTA0bSiYPk+IfyiESJFwqrtVY95h1q1bB/Y4YPkOoH8roFdT4KHv3PaXDvWAvq2AlXvsqN+0JT79dIqqayM4Xe5O8OHAnQJtz2Ogs45FSG+80L6fBFQfPZ6mAqpnzZqFSpUq4dZbb6UlKEJZY55gabrGCPELhRAJmF8PfIRf978PhysDRuWdn1vhnGQqAejdCegtzUMBLMh+//kR7ucVpwdgRQR68ibFpaBjnf+idkoHi7vG9IO2M1dAdVE60xuh+GU0CFkvOgtZHAkJB/wPIQGz4eCnhhZBRiTdkYa/D38VA66xHFHnCmHmX2pqKho2bKimjx8/jlggJ6swVOnzdI0R4g9ahEjAaC0X4u3JKF+sMYzM+fPncO7ceRQrlozk5OzI6Qgig8+hM7+r17nFo/WyxvS+sWC7nWuZfxLXJfFeEuf1wEx38cvZc+bB6oTKIsT0eULyh0KIFPkCnZJUG9c1EucTyU80fry+vV9hYMU7dO94J1dIMv+MUfzSvBYhb3HqskTdKkJCiYVuRUnEL9ARjm0xYwdzrywqH2FgTddY3t+3qJl/sVqEMWQxQiESp4RYFetcgUkEyb6YRmgA//nnn3HpJa1NGSuiv/vOyyJkKdeYftANIkupXj234onlIow5FqG4EMZtUQgR4ouVrsAkQuQM4OG1CGnBsu0ua4vNf6wzRKPUQPEWOb6DkGYRso6rwkv4BeH6E7ErxRYfmBmHyWuB3Segnt3FL2OjCKMLjhD9n+nXt547lpBgYYwQCQh9LZJwu3QkWPbHZQs9LTLMGCuiP0ZaXZicafM3XQ1M+AWGFFsUsSu/c7SLX0aDHNdpXAjPQUudboSEBFqESEDo7/LD6dLRgmXvaus0fayIdpxyxQhZ3DUWbAE/qUot2WHqXJgzRz3LtMyPBTSLkD1kWWPWDNAnJFisdAUmEUF/IQ3fraUWLNurCSwQK+K/jku0gs4j5xoLTTyKWPx69uxpaMtfOPDElAVteWWwNCH5QdcYCQj9Xf6uI048+VtaWD4n/XxrXD96KWaUBW77LzAjA/jFAZRMAk6nA3susOG2/5XC1F8rAb+GZx9CRZV60l7Dgf3HMvHktJx9rVzXBbsdOHzS5TXfzCQVP4ty1dyvl/1xDrO+t8b3igZV6jlV5vvB48GdH+WqOZBU3P2abTYIyQ2FEAkIvVUjPcOG3Ue8415CRzwq1LwQpwEklATKAOq1PJAAlCnpXip8nx86Kte1qQEtw+H02t9KF7iPZaYjnMcxsqSkyMDrfp121ol9Fvle0RJCQnqWPajzo3hFIMkzRSFEiC8UQiQg9HeULtgQH4LG2E6nUz3sdrt66D4AmZkZcDhzxJfdZkdCQjxs+uUMjsvl3le7zeV1vGy6pquhOI5GQP+zxNmdlvlekUcKH+a4Tot8HOUUczF9npD8oBAiRbYIJSfE4e27ywUVB3R5u7Y4ePioZ17liuWxcvUa1bFcQzLDJCjarE03J663I9MJVCtnxwO64/XRry44XED18gle883MnpMpmJsdv57aOhltrrXG94pGfNAH2c2A61ZOwkMdinYcT5xx4oPVTJ8nJD8ohEjUgqVFBJ0/ddSrl9R93xxFu7aX4MChI57lRPyYUQDlCpb2TZ/XWYSsAov3hTZjLNgyFXabbMsnfZ4Q4gWFEAkIvZuqqGnfkgY9bdo0ZQnK3UsKGDT1KBYuXIiuXbvCCtiz68DkbrFhvawxfV8rjrpFx6mrQh5MeQX1c+h+BqbPE5IbCiFSZCEUqEVIKkVLkUSpD6SRV32glStXWkYI5ZU+H+lWJZHADDVrRIiLW9bIrlZ9O5ZgLEJuXcr0eULywzpXYGL4ytJ9+9yCn5YtUFagT/vlXx+oXbt2sAraccq715h1LEKhrCwdrpYtZuhZF6rCpW6DkHF/E0KMAIUQiYhFSO7CFy5agjducCkX2MDWQOWSEhMEr15Sw6a7A6atYw3yX1k6kq1KzFpZOtSINVJ61JmhZ11ILUJ615jBfhNCjABdYyTsMUIigt54441crrCV9wNtJ0hMEHJljVmJnGrLehGpE0IWuh/xbiBrnEFXa9mSOybNmD3rvIKlgzg/7Or30AVLG+g3IcQoWOcKTCIexFnQ6aN3Rbz++uu5XGEXlAdeuc79+rrrrsOCBQtUtpg+dd5SFiGvGkzGjJ8JHmPGCGktW8zSs87bYhhEMSaVNcb0eULygxYhEhAOr2wWW6FdETVSgKvfAe6f7k4mkgFI4oEemOFO8X3ppZcMdUce7mBpq7rG9NYLI9ke6tWr5xHimkXIyD3rvC1CRY8h812TnjFCckMhRALC4dRdSfMZwP25IjrXB1bs8HaFJcUDnTtfbWERlFewtDVdY97p88axPkhgdGrP7nhg5iLlDtOE+IPfxiG1ZxfDnX/eMUJFtwjJTQayK5tnbznIPSPEeljoCkwiX9/EFpAr4otBwOV1vJfr3LU7vpj2FaxMTrC0ziIUwsKURsLIBRUnT5mKyzp0UUK81tNuQS7TMt+yWWM+p5aR3JWEGAVahEhASE+wwlyg/bkiyhYHhl4CLNkKvP/+++jYsaPh7sQjZRHydo1RCEWCsmXLYvaceaZo2RLKrDGmzxOSPxRCpOhCKJ8BvCBXxL/+9S/ECjmC0X+wtLVcY8YfdM3QsiVUWWPu9HnjljQgxAhQCJGAcHhdSPO/QIvLQWq0SHqyhoggI7oiImEl8XZLWNU1loNvAUkS+ayxXMHSBhWnhEQTCiEShGvMZhlXRFjxuMb0BRVh+awxo1qEzNCKI2RZYzYbXWOEFACFECl6sHQhB3AzuCIibRHydo3ZLFpHKGfQPZ+Vhl1pK+BwZsDonDl7Bh9/9CH++OMvz7zmzZvi9tv/heLFi0dkH85mHglNHSHfuC26xgjJBYUQiUpX7FjCf/q8RV1jeXSfn7f1fhw++yfMQsve8qilm3Ma646+BhyN/L7Yg/4/M2a1b0KMgulGsjfffBN16tRBcnIy2rZti59//jnPZSdOnKguzPqHrEci4xoj+aTPW7SgYl6Vpc0kgoxGxRLNLVntmxCjYCqL0BdffIHhw4fjnXfeUSLotddeQ/fu3bFp0yZUqlTJ7zqlS5dW71sxVTnawdIZGZlR3RdTp897FVS0WbqytF70lUqsjlZVjZsx+PvvG/DKq6/g5WuB8jov2NGzwIjvgOEPD8eFF7aI2P7I8apSUlcKuyjossZoESLE5ELolVdewZ133omhQ4eqaRFEs2fPxkcffYTRo0f7XUeET5UqVSK8p9ZEeoe9/MpLuHKQe3rjps3o9VwPlQUmgdGk8OnzVnWNeX2XbOGnt0IUT6iAhuWzG8wZkeqNsfK7x7C9FNBOpz8mrwVWfgdc9PKtaFDeZPFuups/hggRkhvT2OQzMjKwdu1adOnSxTPPbrer6ZUrV+a53unTp1G7dm3UrFkTvXv3xp9/0kRfVKR32M6tGz3TtVJcqpeYpMiTAIOlLeoa01tcc6xe5hF9OfWv4pT42X3CLYLc9a+6mzPoX19HiK4xQnJhmivwkSNH4HA4ULlyZa/5Mn3gwAG/60jXc7EWzZw5E5MnT1bxLe3bt8eePXvy/Jz09HScPHnS60Fyeof1uTjnolq+GDD+OoeaLynyJA90QkcTQLGUNWY20WemVhyFg64xQizjGguUdu3aqYeGiKAmTZrg3XffxVNPPeV3nWeffRbjxo2L4F6awyU2INvqU6+iHbuz50uFEqkYLUidIFPeLUe87YQTNsRZtumqvzpCZhN9ha1/Fc06Q0W20tE3RkguTHMFrlChAuLi4nDw4EGv+TJd2BighIQEXHzxxerilhdjxoxBWlqa57F7tzbsxyZyse/RvSu2/LleTW89lnNRtblcqm2GIIMB8Y+3FSQ7bsa7oiKsgnf2vNOUFiENETc9e/bMJXLkxqBXag9lcU5NTVXuNJk+fvw4jAkLKhKSH6a5KiUmJqJ169ZYvHixZ564umRab/XJD3GtbdiwAVWrVs1zmaSkJJVppn/EIvqL/Zpf1uHNG5xIbQzM/CvnlDly2mXu2IloZFJZ3jVWkEXINJecfGPlJDZucn9g12NQz2aJlWOMECG5MdVVSVLnpWv5J598gr///hv33nsvzpw548kiGzx4sLLoaDz55JNYsGABtm/fjnXr1mHgwIH4559/YqrhZ7AX+5Gd3NMd6rov+LXL5VS53XQIqNfkIhPHTkQKW67WCV5WEnP9Gxah+7x5gqULGys3obcDA1oBNctAPY/u5I6VW7hwIYyGt9CmRYgQU8cI9enTB4cPH8bYsWNVgHTLli0xb948TwD1rl27VCaZhpiqJd1elhW/v1iUfvrpJzRt2jSK38I8F3sRPpfUBF5cBqzY7r7gD7rUjs3Zy7kcTkz57HOmzheAXdciIUcA6V1jdktXljara8wfEhOk3RgIx84Cgz4D5mQnU3br1k1ZSI1UUkLfa4wyiBCTCyFh2LBh6uGPZcuWeU2/+uqr6kECY/ny5Z6LvdzxikvsgRnuca1Uh5yLatly5egSKxS505e93UWx9F3N/W3r1XNnB3huDD4DVu1yW0vl/0XmPzDT7SaTgGsj4HXEvdq8EEIEc9+ekbDEBd11111qWi7qglzkL6vlTiMe/0POKdO8WeQq7JoZvRXEEyNkWddY7u9ipe+qrzP04lK3JWjC9fBykxmvpITeIkSbECG+mPuqRMIWBHp1feD+6e5icqczgH4XAynF7KhWIyfQPDEhMar7a9b0ef2zewEr/RvqU7X9WIQs8F21OkOjZsPLTaahLylhDPzFbRFCNMx/VSJhCQL9ajDQrja8ispd3qkrbr21j2cduwUGtUjgbQXRRIFFe42ZvLJ0IHWG5s+f72U51TBaSQmv84t1hAgxf4wQKZhzmcexaMcoHD9X+DvSjMxMvLrkQmQWAyZlXzf7dANudAKnzgMlSpRAUlI6DjoetWT9m+i6xqx0HHNnKFkpWFqPFhgtMUEul0NZgkQEuUtKdDFQ/ByzxgjJDwohC7LjxEIcOL0usJXsQImUePjrJ18iSf6mI92R7r2KhQa18OKv15M1XWPe3ef910wyS0XmwrrJJDB60FS3dUgQEWSkkhLeVjoGSxPiC4WQBUl3nPa8Lp5QEQn24oVaT3qwnT93BpVKAsUSxLIEHDoNJBcrgRo1auB0xgE4XOmWCXyNjkXIeplUgVSW/v77H/DkkBc900ZLNQ9XO45o4vJqukoI8YVCyII4nRme1x1qj0XN0u0Ltd7xasfV3a3ECvkbqGZvuQf7Tq3xvEeLUFGsJJoQ0r1vqeOYf2XpIwcPGDrVvKiI+DGaAPIfI0SLECG+UAhZEIcrRwjF2RJCdnfrbhZq1QE8sjFC3gOSLWYqS7eu7sKA7NNIgvIltkbcSnLOGVVIhIqouQT9BrATQjQohCyIw5XleR1nSwzZ3a2+QrJ72joDeDTT563lGss/WLpyCVeeqeZWFUJSn0tKU+RlaQ03bLFBSP7wlt7irjG7PXS1fnxjghgjVPT0eatmUhVUR+jgKWOnmluzSasfiyQhxAMtQhakqK6xgvAdsPV93Ug++HONWbWOUAGVpVf/Y0PiXzBwqnn4+vaJKzA6LkFahAjJDwohC+Jw5STB20MohOw279PFSgN4VCtLW+o45v9dK1SqhkGP7zRsqnm4m7RGwyXo7/wjhORAIWRBnM7MoGKECnu3z6yxwhFTvcb0gbme75gz+Pbo3hNDNk80bKp5uJu0RsUlyGBpQvKFQsjqrjF7+Fxj3oGxpHB35A4//besdBzzD5YWN6GRU83D16Q1mtWn9enzEfg4QkwGhZDFXWMhtQjlyhrzniYFHzf/MUKxVVk61oh29Wm6xgjJHwohC+LUCaFFC5eiYf2mIbnztPvUEWL6fOHwHvxzZ41ZqsWGv8rSetFnoe8ayurT4awxxPR5QvIn9q5KMUB6xlnP6+uuvV6Z53ul9sDx48dD7Brj6VP0ytJ6KwksXVlaXzwyFi1CGiJwevbs6SV0pMaQ/G82atQIqampIftf9SbnmDtZWZqQXHAksyBbt21yv3C6sHNM6OqW5HaNxe6gFhD+gqW9hJDd0pWlrfpdTVNjSH/+0SJESC7oGrMYYmI/c+4UyqIY4lwu1CwTurolubLG7IwRKnKMhlezMXtMBUuTyNYY8jr/nBRChPjCq5LFkDiD+AT3hS/O6fRbt6So5GqxEcNujiKnz1s8gNg7fd7a7UQiUWMoNDB9npD8oBCyYN0SjxDS3YmHom6Jr2uMMUJF7/5t3YKKuS2HXsHSvOT4rTGkJ9Q1hrwsQmyxQUgueFWyGBJsWaJUMfX6/HkXdp8AJq/V6pZ0D8rUnrugorUG8HBh02XbOT2uMStnUtl83IBWrZkUqhpDcep/1Pd/VUTL3LlzlYssKHTHnMHShOSGMUImx1/abUqZEshwnsKBE07Uejp0dUtyBUuz11ih8Br8/aWUW80iZLO5dV622HNmF5FU7/Heq8AaQ106d0BmZqbKJAtFt3rvGDVCiC+8KpmU/NJuterFF9Spjzlz5iixJHVMinIRzb+OEE+f0KTPW9UipKXPM1i6oBpDKnA6+381MTERa1cuD1kmmbdrjBYhQnyhRcgCabcSbClxBlLGXy6WNz7jbrFRLKmEqlsStu7zHNSK3n3eSxxYzCKULeysHhgeSrS2I+HJJNO7xmgTIsQXjmQmRLtYTujtUBdJLUV+/HUOzJ03H05Xllouzh669hoC6wiFp/u8ZcWB5ga0aINZs2SS+Wv6SwjJgVcli10s47IzxkLdZ0xg9/kQusYsLA60gdevRYjiOQqZZOw1Rkh+WOsKHCPkd7HUUucFuy10nefd22OwdPDB0n6arlpMHGgWLn9CiJec4DLJipL1yfR5QvKHMUKmvlguUrEDYgkSESQXyx49rgZwVC0XF2IhlNs1xkGtcOQfLG21OkI538cVA6UCzNCtnjFChOQHhZBJU+Xzuli+8fYEzNndLzwxQrlabFhtAA8PesHoqbZsaddYtkWIlaXD1q2+6NW+KYQI8YVCyCSp8pIlJgHSvnVFjhw54nWxPJm+J4yuMe8BO45394WkgPR5m8UrS1tY9EUikyxYvMUnhRAhvlAImTxVXu4c9RdLhzPT8zr0WWPepwtdY8Fk7egHJGtXlray6DMD+mNO1xghuaEQMjiB1hVxutw1hMJhEfK9m2e8RzDp89auLO2GwdLGILdrlhCSA69KBmb+/Pl46qmnAqor4tAJobhwu8YYIxRE+ryVrSRajBCDpY2AXmjTIkRIbmgRMiASEH15u7Y4eNid/SWIO0yzCOVXV8SRXUwxPHWEmDUWuvR561pJWFnaWHgLbQohQnwJ+Aq8a9cuv5kHMk/eI8EjIuj8qaOeXkMtqwH3fYNC1RVxOnUWITvT540bLI0YsJJYP0NOc1+HpEt82GDWGCEhtQhdcMEF2L9/PypVqpQrs0neczhyOk2TornDxBKkjwlacg9w9TvAIF0ZkbzqiuhdY+HOGqMQKkqwtB/XGGDNytLZg65Vg6Xzy+YMtsFxKBErXI4dkjFChAQthOTi5u9idvr0aSQnJwe6OZKN9Af7+/DX2Hjucwx6vBbKtQRW6Dxb/3sdmLoeqF+vPi5udTFSSpfGhpOvAye9t3M640DEXGPsJF70GCFru8Z8Cipa9LsWlM1pGLxcs9HcEUJMLoSGDx+unkUEPf744yhevLjnPbECrV69Gi1btgzPXsYAu9N+wk97XkDxWsCVtSogpxpQDlfWkb8ncCBzKQ7khA/lSejT532yxixny4iARUiLm7G0u8iW53e1ihUxPF3iI2ARYtYYIUUXQr/++qvnorZhwwYkJuYMsvL6oosuwiOPPFLYzREfTmXsDen2EuwlUCvlirDGCFlvAA8P3r2e/KTPW8hdVFBlaatYhArTJd5IQkhDf94RQgIUQkuXLlXPQ4cOxfjx41G6dOnCrkr8MH7WKWRk5VyUkkqdQ7HssIKTh+7Ab7+UQGZWTgZYQnw8GjdpiqTkwll5nFlV8O7OYrK1kO1zfLF0lKwIyw7g4cJbMPpzjVntOPpUlvYSfXbLNT4uTDan0WLUCCFBxAh9/PHHnjseuSvq0KEDihUrlmfsEPHPtgNZOJeRM0BUruJA7WwhdOhEVSSV64gkn3V2HAz0U3KEVChIKQM00gshi9zdhxt/vZ6s7BrL6T7vLzDcZvnGx5LIYBRrkMDu84SEWAhJpsQtt9yiLERygRdfeN26dXHHHXeoTImXX3450E0SNVjmDBaGvVS5fAdsaw3g4SPGeo35VJbWW7+sJPpC3yU+TOiFeFR3hBCLCKGHHnoICQkJqmZQkyZNPPP79OmjAqrDLYTefPNNvPjiizhw4ICKS3r99ddx6aWX5rn8l19+qYK7d+7cqe7Snn/+eaSmpiLavDK0jNf0hkPJ+GW/+/VdXUuhThnjpN9q7DuVgvnbYdkBPDJZY7l7jVlJHPirLO1l/bLQORPqLvGRjFEjhAQhhBYsWKBq3dSoUcNrvlwA/vnnH4STL774Qomtd955B23btsVrr72G7t27Y9OmTbnqGgk//fQT+vXrh2effRbXXHMNPvvsM1x//fVYt24dmjdvjmgSH+c9INhsOYNFXJw91/tGID6OwdLBu8YcflwUxvutgyHnvIiNXmOh6hIfkfOPNiFCchHwVenMmTNeqfN6l1lSkm9US2h55ZVXcOedd6qA7aZNmypBJPvy0Ucf+V1egrp79OiBkSNHKuuV9O1q1aoV3njjDRgP41sIfOsIWenuPlLHzW/bCYseR/8NZo15blsZxggRkj8BX5WuvPJKTJo0yesi7nQ68cILL+Cqq65CuMjIyMDatWvRpUsXzzy73a6mV65c6Xcdma9fXhALUl7LC+np6Th58qTXIxKYoRu53Sd93op39+G3CFlfHOSqLG3pBrMmwE+wPiEkCNeYCJ7OnTvjl19+UeJk1KhR+PPPP5VF6Mcff0S4OHLkiCrcWLlyZa/5Mr1x40a/60gckb/lZX5eiBtt3LhxiDRevnuDDha5CypaawCPaPq8fkAy6O9ddGIjWNossI4QIfkT8FVJYmukquoVV1yB3r17K1fZjTfeqAouarU1zMyYMWOQlpbmeezevTtCn2z8wYKusSLiL33ewh3Zc9LncwdLW0/0GR+73xYvhJAiW4SElJQUPProo4gkFSpUQFxcHA4e9C6mI9NVqlTxu47MD2R5QeKcwh3r5A/v0FmDCiFahELWa8zSrjFP1pifUgEW+66mgK4xQkIrhH7//Xe/88U6IE1Xa9WqFRYhIW08WrdujcWLF6vML0Fik2R62LBhftdp166del9S/jUWLlyo5hsOL9cYTBEjRItQEOnzJnCFFhkfwWxl0WfWgp6EkCCEkDRWzekl5Mr1jyY1hqSm0LvvvhvybvSSOn/bbbehTZs2qnaQpM+La06yyITBgwejevXqKs5HePDBB9GxY0dV26hXr174/PPPVWzTe++9B6NhhrvmXN3nDbqfRiPmgqXzqyxtNdFnAhgjREj+BHwFnj59uqqZIWLit99+Uw953ahRI1Wn58MPP8SSJUvw2GOPIdSIwHrppZcwduxYJcjWr1+PefPmeQKipcjj/v3ZVQkBtG/fXu2T7J8UX/zqq68wY8aMqNcQ8ocZWi7QNRYu15i1xEHO92GwtBHwPuYUQoQEbRF65plnVH0eSUPXaNGihSqwKBWcf/75Z5QoUQIjRoxQoiXUiBssL1fYsmXLcs2TdiDyMD7Gr77LYOkQCEjNOmJp11jelaUt911NgP6Q0zVGSG4Cvj3bsGEDateunWu+zJP3BLHW6C0zxBqusVwxQgbdT3NYhIz/e4ejsrTVvqvZhLiTLTYIyUXAV6XGjRvjueeeUzWENDIzM9U8eU/Yu3dvrvo9JH/M0HIhl2uMd/dBpM/D8uIgFjLkzIH+/5QWIUKCdo1J09PrrrtOucIuvPBCNU8sQVLscNasWWp6+/bt+Pe//x3opmMaM7RcYLB06CxCeteYUX/vUAhmJfws/F3NgF3/e1AIERK8EJIA5B07dmDKlCmqsKIgMTj9+/dHqVKl1PSgQYMC3SwJ4V2z/C7btm0LeTdsBkuHLn3eu7CdzdIWCCddY1GFvcYICaEQEheYuL/E8nPPPfcEsiopAK87NR/BUVikzcmggf0xZ+58z7zUnt0xecpUlC1bNuh9ZB2houF1nGIofd7zPb0Cw631XU0Bg6UJyZeArkpSI+j8+fOBrEIKiVetlSJuQ0TQqhWLMLk/sOsxqGeZHjigX3iyxiw2gEfWNWb8LMGio/8+Tku3EzGba4wxQoTkJuCR7L777sPzzz+PrKysQFcl+RCshUDcYWIJmtDbgQGtgJploJ7HX+dQ87ds2RL0PjJYuoh4xczEQNaY1/e1tvXLfK4xZo0REnSM0Jo1a1TbigULFqj6QVIzSM8333wT6CaJIjjXmMQECR3qes/vmN0Hd+vWrUHHC3nfWao5QW0vlpteeget2izsGnOysnSUYWVpQkIshMqUKYObbrop0NVIQK6xwAeLevXcimfFdrclSGO5Wx+pwOlgsfmcLry7LyR+snasLQ68g6VpEYoycn65gus+H64EDEJMKYQ+/vjj8OxJjBNsy4WGDRuqwOgHZi6Cy+VQliARQQ9+G4fUnl1CcvGiayx0rgkri4NcTT4ZLB1VlCVXO91cxkrAIMSUQoiECS/ffdEGC7k4SWD0oKn6i1YXNT8U+A7YVhvAI9p93mtEslu6t5XeCqF3E5LIC9NM13EcO1f4eMH7RtyLHXtWYdIDyWhdA1i71YGHprgTMGbPmRemPSbEBEJImpdOmzZNNTnVV5gW1q1bF6p9iylCUVBR7tDk4iSB0RITFPo6Qr77RYtQUdLnxc2w+9A/QHHtfVgWFSNkYdFnDnJOsBNZC/D13wsKvebV9wNXoxEkV/hHmdEZeKnhHtz+iDsBg24yYgUCvipNmDABQ4cOVS00fv31V1x66aUoX768qibds2fP8OxlDBDKlgtycZLfItwXKbrGCkvO7zlv/lw0atQI8xfkWO1OnjwNK+HtQnVZPB7K+CTaKsHlCp0AtbWqoJ6XL18esm2S6LJ582bMnTs3JNnFMWEReuutt/Dee++hX79+mDhxIkaNGoW6deti7Nixyp9MQuEa42BhJfTCNq7EMXz8ciUUu6gYTmbP+79RI/HFJ4tgHbxjhKwcD2UGEuwVsGXTOJQpuwqNqsWhchnfVjn+SUtLwxfTpuGq+kCDCsCuMqVwtngSMlOSUa5KIu68805M/+YrxguZGMaAFVEIiTtM2mwIxYoVw6lTpzxtNS677DK88cYbgW6SmKTXGCka+t+zZpPiyJSH7v0VK36wlJshv8rSPLcjjxzyEycuU49OdUrg8tpJhV737dEbMPK1Raoe2c+1qqDFrdXU/Hc/qYOTRzPx3ZLfMHBAX8yekzOQEmMjNye/HvgAe0+txh9//IGLbjmOG+9pgJRkIO08sO3oDoz/LhUP3jIFZYv51GOxKAHfnlWpUsVj+alVqxZWrVqlXkv/MZZvLzq8a7YupZOqI85R2u97SecycHhPhorpioXK0owRijx67ekM8BItloHLOnTBoKnA3Pnum17heIWScDQqi9R7q2HvmdUx61IxI0fPbcTa/e/gwOlfUaFOJi64qCScNUrheIVS6lmmqzfPwPItryBWCPiqdPXVV+Pbb79VryVW6OGHH0bXrl3Rp08f3HDDDeHYx9jA0i0XYhu7LQFtS7+Mtx7ZhsRvt6PzH+5Hlw3bYPvgbziyXCGp82QUWFnaWHiX43AVKQHj/fffx/YNZ1D2SO54tgatSmLq1KkUQybhXGbhQlhOnj2AWCFg19ijjz6K6tWre9ptSKD0Tz/9hOuuuw49evQIxz7GBNbuRk6aNWqFasmXYfhLbjeDVufpIVXnqbtl3GICK0sbC6+kxSIa7Tt06ACnAzj/yWb0a5eA9Ph4fHNpE/VenabF8cRdT+CJJ56IyfgSs+GEw/P623f2oc+5A+h/sXvaYbNjYseW6nVysWTECgELIblz3b9/PypVqqSm+/btqx5Hjx5V8xyOnINMCo8Z75qtFNcSCcJd58k4+FogzHduW4lgXGO+BVsfnLkIcGWiY71MnDqUjlKVktCwRXGsfb00/tjjxMj3FrPGkMHR35jUq9sADz59GHC4b86WbXcCHd3vJScnIlYI+KqUVxzQ6dOnkZwcOwoy1Jjhrtk3K1Aujr1Se+D48eNR2yczobkZVIPcOXPUs0xb7e7Zu5I20+ejTdEdY3nHC9V6Gtj8+1n3G4lxWNu+PtJvbYj/fnCBykBauHBhsLtNwoT+/7Fvn/5ev+ngzxCTfekKbREaPny450ImqfLFi2dXgxNzmsOB1atXo2VLt0mNFAXjF52TNMvrn86ZntwfqqUH7wADQ6xoVrak5aojxGDpqGIPgWvMt2CrxAQtXDkBrbt4i/j4OqVQsUYiunXrRjeZQXHpXGPFi5fIVYR32al+2fW/Yse7U+irkhRPlIfc4W3YsMEzLY+NGzfioosuUnWFSHR6jYUbZcXQ1ZoQpLmrxLvIfAZKksJUlqZrzJwxQnpExEs4xI/fHkXi7B1ovWMfDvya5nl/+n9Lq5ukVSvcN0mBEOuF/SKB3qtjs7lrSumL8Gr/o0Vt0Gtpi9DSpUs9mWLjx49H6dL+04FJ0TC6+0A6TwstV2/HrmZV0GL3ITUtfmVB7iasbOUgQfQaM/i5bXVCLYQ0t3jP7t0x/PlFGN3JgQ+3F8ejk1PUe2drlMaAVkeURUHi4QoTS8jCftGxCPm7MbHZ7Oq30//fWh17UbrPUwTFnmusXj234tn8wwnctGYjGh5wxwtJ5pNgpfRvEiS+3edpETKOEArhdrWYoVGzgV0bzyI+0z3AHilZzGs56UtZECKCxIIklqRdj6HIFiVSMN43Jn6EUAxahHhVMghGdx9oWSMPzIzD5LXA7hNQzw9aMP2bhLayNC1CxgpeDxVazND8+fOVpclx3i2EMl02VPkvVACu8Nhjj6FCubKq6G5+bvcJvR3K3V6zDN3u0bYICbQIkYjjPVjAkPhmjcizTFsv/ZsEBytLW901pkcLjD5xzj196DRwNhNo6e7GoTh6/ASaNWnkN8NUc7t38OnmoHe7k9Dh1I019vwsQq7YCZYOuI4QiU3XmG/WiJZhQEsQ8YWVpa1XR6gg5GZo0q/d3MLXBgwYXg21LiuD+0rakJwAnM8EjpwBPvq5i6cgr0ZmlUw8M7MZ5pcESiYBdqcLTfcexvq1h9X7dLuHsa8lcjfgtWcHUDN9nkT55DT2YGH19G8SLKwsbcX0+YJukqSg7umMAyhTMRGtbq7i/jxp6ZC9TPky7udTGXtzrV+xRpJaVutmtrJudTw27zhSe3bmtSbSMUI2LUaIFiES1ZRGDhbESr2taBGysmssh9y/bZzDifgsh+pqnpGVMz8xKREppVNgt7vXcTqdSDuZhrhEBxIS7UC8He07X4WP3qPbPdI33bbseXoXmtWhEDIM+isUhRCxUGVp/YWXIt+0laUL/pzcv22j/Ufwv//bg1W7gAnXu+OAVmyXQqxxKr7QtxDrjN/vw+GsVer1pMmfoFQSU+dDjT72J1+LkIsWIRJhzOQaIyRffCtLe91Z8ty2qkXIn8j9dTcwZ6M7HV4ywQR5zqvGUJnSFXA4u5NPlvN8+HY2hvFyjfmJEbJ55sVOjBCvSgaBcRTEmhYIVpY2lhAK5+CW+7f9frsroIyweHtOv0qHi0Io7Onz+ViEnDFkEeJVyYBwsCBmhpWljVzXKTKfo3HDjTeqZ3GH6cmrEGu8PcnzmhahSMSjsqCiQNeYQfCutcLBgpgYVpaOufR59Tl+rlt1al+QXYh1kXKHiSVIRJC7EGuXXBlheotQljM9fDsbw7CgYm4ohAwC75qJVbPGKPJjJGvMr3XBpmoMSasMiQnSEBHkrxBrnJcQokUoHOizwWgRckMhZBAYR0GsX0fIRpEf5TpCiLBFSMRRIIVYvWKEaBEKC3qBY/cXLG2jRYhEDabPEwtWltaJfAp8A7jGwvk5fq5b+nmFKcQab2OMUNTT5xF7BRV5ZTIIdI0R66D3xTjdjzwuuiSyhNc1lr8QKgxeMUIuWoSikj5vy26xEd7qm4aCVyaDwLtmYtXu885sOwTPbeu22Mjz9w1Q/MYxayzseBc4zf372GkRIlFDF0dBiJWEUI5FiOe2lesIFeQaKwzeMUIUQuG3COUtXhkjRKJnEaL7gJgd/TmsWmzQ2hlN9AL07z1ZmLL8TFg+53xxF3w9LRv+ycKmLYX/PEecCyjufv3973uxcs0+lElJCcn+lSpmQ6fmyShdPLbPw4IKKtqZNUaiRc5gwbtmYrXK0rR2RpM43WHfe8yhHuGgaXOgZEnveTsPObFvb+FjfUqUtKNZc/frk1nx2LUnGdgTulihE2dcGHxVCcQy3vGoeccIacvGws259b+hWaBrjFi8snQsXFCNSPXycaiUEolj7+/aFdj1zOnMiRGy2zMQag6mxU7cS15oMXt66483etd2bBwv01iEjh07hvvvvx/fffcd7HY7brrpJowfPx4lfW9BdHTq1AnLly/3mnf33XfjnXfegdGga4xYB9/u83SNRZP4OBvG9U3BvuOOsNYRWnUwHmk+2qVTs2TUa1+6UOv/888/+Ne9t6PFuwlq+iLMwqDzMzH7b+DxecCMGTNQq1atgPdLwqKe/uqkeu2IHW9P3hRQUNGuswhJ8UWvOlQWxTRCaMCAAdi/fz8WLlyIzMxMDB06FHfddRc+++yzfNe788478eSTT3qmixfPdkAbDA4WxCp4B0XLec1gaSOIoVoVwnu5X38sLpcQKlMyHrUqFu5z//xlMw79sxFACzWdZEtDLdcOXFMF+Pce4NShTajV2qd7ayGxZZ+JjnD2GDGhRSi/FhtuYkM5mkII/f3335g3bx7WrFmDNm3aqHmvv/46UlNT8dJLL6FatWp5rivCp0qVKjA8MRShT2KtsrR78MlIz1TVhQsqqkesQyDSt169esg4n3MdzIqz59ugNRBkU1lOWoQCKajo247DypjC/LBy5UqUKVPGI4KELl26KBfZ6tWr8113ypQpqFChApo3b44xY8bg7Nmz+S6fnp6OkydPej0iAV1jxCroL6Ty/3Pw4H71+vjxE2jYsCF6pfbA8ePHo7iHJBz4v3YV/nom58bVnTp7ps847Zi8VmvQ2j0oAZ2tqSiEfOsI5dNiI5ZS6E0x6h44cACVKlXymhcfH49y5cqp9/Kif//+mDx5MpYuXapE0KeffoqBAwfm+1nPPvssUlJSPI+aNWsikicnXWPE9OhcYF//+CjikzPV60olXJjcH1i1YpFqwkmshp86QgHe2H0ycarHOL7uoB2DpgKXdfDfoDUQ4rJT5+gaC8wi5GKwdPgZPXo0nn/++QLdYkVFYog0WrRogapVq6Jz587Ytm2bMsP6QwTT8OHDve5oIyOGNIsQ4yiIudE3cqxUX0SQezrB5kK/Vu4LsXQip5vMWvgvqBgYcnObsCtZVZVu0KguNm/+LiTniGYRyoqNcT2ABt8Fpc/HhnCMqhAaMWIEhgwZku8ydevWVTE+hw4d8pqflZWlMskCif9p27atepYOyHkJoaSkJPWINDknHIUQMTe1y3TEhkNTkOn0LqRX/4DbHdYx+19P/g8phKyEv2tX4BZuqS4tQqhYifiQnR85rrHYGNiDswjZcpalRSj8VKxYUT0Kol27djhx4gTWrl2L1q1bq3lLliyB0+n0iJvCsH79evUsliGjQdcYsQoVijfGgBbz8OeWn9GjRw+8eA1wYyMnSmRkhiz4lRgPv4NqEWIe47I70J/LOoYfd+fvMZBxIS0tTYUxSBxpXlSulo7iZ1Nw9uS1AMoilimoxYbNp6BiLGCKrLEmTZqoC6qkwksNIEmfHzZsGPr27evJGNu7d69ye02aNAmXXnqpcn9Jar1klpUvXx6///47Hn74YXTo0AEXXnghjEZO0TlahIj5SYgrjpaNO6F10054aOIi2K5zKEuQiCB38GsXWoMsRihcY0KCvZh6znKew1+HpxW8QnHgTCaw73Dei6SUdz+OHTkC4CnEMgU1XbV5xQjFhhAyjflBsr8aN26sxI6ImyuuuALvvfee530RR5s2bfJkhSUmJmLRokXo1q2bWk/ccFKEUQoyGhlahIiVkCBXCXaVoNdaTyNkwa/Euq6xC8p2QbhITNqDWMepc43ZCyio6KJFyFhIEF1+xRPr1KnjFdglAc6+VaWNDPsxEStStmxZzJ4zTwVGS0yQuMNoCbImoXKNtal2LxqWvwbpjtN+39/1zz+48cYb0agisOM4kBwPjOoEXFwD+HUP8Nwy4KLW7TB+whvuFVwuzNg0KHt/Qt+2w2rp82CMEIkWdI0RKyPihwLI2oTKNSaUTso7U/eXnTuxa+M57NqYbXXsDwyo4X7dvAZgawIM+nAJxv1fTrC1y5kAmz2TQihX09X8Y4RYUJFEGM2axZ+EEBK7rrGC8M347eDTdUOflajhQqJ7D+2ZcMZ45pi3RciPa8xrHoUQiUqvMVqECCHmo6BU7FAhFag7dLjCM71iu/f7frMSXW4hZLdlxnx16YLS56GbFysWIbrGDAJdY4QQy7nGwnQ9mzHjWzRp1AAnjh3F/dPdHea1rMT7Z9iQ2rObtys2WwjZ7BlKCLn728cmBcUI2fVZYxRCJLLQNUYIMTORcY1pQfh/b9qCa3qlYtWqVSobUaNrl6v8ZCVmW4TsYhGSa23s3nAWHCNk101RCJGoFFSM3X9QQojVgqXDdz0TMfTjTytVRqKWIdyxY0f/Qfkutw1IgqVj3jWmEzf2goKlERsHi0LIIGip/+w+TwgxI/6tCzZDZCTadBahzCwZ3GP3Ouvt7iqgxYYunsjKxO7ZYDi0YGn+JIQQMxI511ig2LKjgmw2J7KcsTG4FypYmi02DHSWkpgpZU4IsSaRdo0FhtsiJGQ6zFlLaPPmzZg7d65yBQaD5u4SEeTPYmdjiw0SLegaI4SYmWi5xgqD5hoTMh3pMBPHjh1Dr9QeaNSokWovJeUDZPr48eNBWYTyGmtsMZg1xlHXMNA1RgixGsa4nplZCA0a2B+rVixSFbR3PeaupC3TAwf0CzIxx197DXgJJLbYIBGFWWOEEDPjN97EINczuy3R4+TJdGbCTO6wOXPnu9uItHLPk2ex6gyaOl+5yQJtXZNTsy4Pi5BNHyMUG1W4jSHXSc4JZxBTMiGEBIS/a5dBrmdmtQht27at0G1EAr/p9j/82xF7FiEKIYNQ0MlJCCFGxsjB0mIR0sh0midYWuurVqg2IiGyCMEWezFCdI0ZBvYaI4RYzTVmjBs7uy2nqUaWibLGJDA6tWd3PDBzkXKHaW1EHvw2Dqk9uwTsFtNbefL6bWy6+c4YsQhRCBkALz8ss8YIIWbEwK4xuy3J8zrLaR7XmCDtQiQwWmKCNEQE5W4jUji0Rqp2XSyQHq9q0zESI0QhZLgmeMa4cBBCiFVcY3E615jDRMHSWiuR2XPmqcBoiQkSd1hRLEE5FBAsDX2LDVqESMTQ+2GNceEghJDAyL84X9RdY67ALUKStSUBy8GLj8i0EgkoRigv15jNFnMxQsY4S2McL88YXWOEEBPi99plENdYXICusVAXMTQSzgILKsZ5XrOyNIkYdI0RQsyOkV1j+mBphyuzSEUMf1y2EN26dQm6xUW0CaigootCiEQMusYIIWbHuK4xvUXIUYBFSCtiOKG3QxUvLJEIfLYOSDvnxC+/rDO9dajAgoqgECJRzhqja4wQYkaM7BqLt+uCpV0ZARUxHPQZsGoXQtbiwug162xssUGiAV1jhBDzY1zXWJy98Flj+iKGl9QE5mxESFtcGMcilJdrLC5nWS3C3OLQ/GAIaBEihFgxRsgY17N4e45rzOlKL2QRwzi8vwohb3ERbXIKKtoK4RpzIBYwxlka43g3tjPGHRQhhASC/5s4Y1zP4u2BBUtLscLLOnTBS8sR8hYXxrcI2XMta3UohAwAXWOEEPPjxyJkwBghZwExQvoihhI4fUmbVso6NHktsPsE1LO7xUV307nF9Onz+uaqeVqEGCNEohIsTW1KCDEhZnGNOZCGMxmHCrVetdopmDHnc9w/7N+4f9FyYJF7/tW9OuL1N14v9HZCRVJ8itd3CSpYuhAtNlxssUEiB2OECCHmxr812yAWobgci1C6fR4++2NeQOv3+D95tNDNOYbZu/sCuxFREuNKoVeDt1GheJMire8WNq4Cxhp7zFmEOOoagFip3kkIsTB+BlajuMaKxZeH05kTJ2RWMhynsO34whCFYRScPu+MkRghWoQMAF1jhBCzY2TXWHJ8GWzbOhrlyi9HpRSgZoXwDn0//fgDjh05hIuqulChBHDkDPDbfhvKVaiE9pdfEfD2Mh1nsPfUavU6I+tkkfdLH/ycl0XI7lVxmkKIRAgvlU7XGCHEhBjZNRYXBxw/1kE9qjdNQte6JcL2WRJg3W3wS161hwQJsh40dTs2b54UcJD1qfR9+PzPa9XrDMfpIu+b3tVFi1AOFEKGgOnzhBCTY2DXWJxu137ZloFtB7LC9lmnThXHjf9Zgb8qAf/VGVcy2wI3XgC8s6wYSq1NC2ibNrsT1bIz9f/aexzf/xzY+p7t2M6hWrYG23HQhf+uy72d5BLnUL66+/Wi389ixrKifVag1KkUhyFXl0Q0oBAynGvMGBcOQggJBP/2IGNYuIsl5Ozd2XQXzqaHMwi4OMpVb4Zc+WR2oFx14GQmcPJYoJ+f5BFCWc7T2Bvw+tm7EJeJatmv0zNtfreT4rShfPbrU+eysK+InxUoJZOjN/ZRCBkAusYIIWbHv+gxxo1duVJx6NQ8Cas2pcMZgYzw8+fPw+l0IDFOGr5KEUdxaQF2exySk5OLsMU4OBzFEBd3DvHxZ5BYxJE7Ls57rPG3nXh7zu8YZ3cV+bMCJSGeQijGYfd5QojZMW5BRWFAhxLqEQmkM700ZZUu9hpSgFEqVkuxxqLw2YZSOJN5DuVKn8Obd5Ur0jbOZ9nw6e/u181qJmHEVbm3s+dkaczN7hyS2joRbaoV7bPMBIWQAdDXrKJFiBBiRvyLHuMIoUiiVaaWpqzSj0xacQRbhTohriSQeSioYGl98LM9rxYb0DVdZbA0iU4dodi8cBBCzI7dsDFC0ULET6jacCTFlVLPWc7zcLoyYbclBJc+X4isMVeMpM/H9llqGNhrjBBiwTpCBnKNmRlJyT+475hnOsNxJvj0+Ty8DzZb7FmEKISMljVG1xghxISY3TUmYmPu3LnKnWUUjh07hq5drkaTxo3w88rfPPP7DbhexSEFN9bk5Rqz5SzPFhskUrj0vcZMdOEghJAcjFtZuiCx0Su1Bxo1aoTU1FQ0bNhQTRdFaISaQQP74/vlS5GSDLSvmiNKNm9co4Kxgyuo6H+ssdEiRKIDY4QIIebGn+gxg2tMxMaqFYtUJehdj0E9y3RRhEaoLVSSdZaeBbx+A9C0TI6IGdXDrt7TW68KY9HybrGRR/d5hDdGyIiWNwZLGwC6xgghZseMrjFNbOjbYcizy+XAoKluoRGqYOdA2bZtm+d1h7rAEUeOEGpW2y1iJCOtfPnySsz5pur/d9xTOHLkCOLipAaRQ2WuVawZX7C1zmYPi0VILG/+9jOYkgIxJ4SeeeYZzJ49G+vXr0diYiJOnDhRKIHxxBNP4P3331fLX3755Xj77bejdmIXriOwsS8chBBiFdeYJjZEaOjpWA8eoRGt8aJeveydALBiO9CyWY4QWt+gGka8Wwmnqk3Bu0vH4cKbjuPGuxsoF9qxs8DWI9vxxa8DINpUu89evBuoVKUsytYovEXImY9FSESkHD99aQB/83alfY/daT9i1uzvULn1Hnx0c01ULQ3sPwl8v+NvvPD5NejV6xqkJNdGi0r9EQ1MI4QyMjJwyy23oF27dvjwww8Ltc4LL7yACRMm4JNPPsEFF1yAxx9/HN27d8dff/1VxOqe4YLd5wkh5sbIlaULEhsiNPQNUpdnG2NkQI8WEqskFpPFC+fj/unAKw0dQEP3e67yxdCoPJDm+BsVLgAqoKSSLMezj3iD2nltNafHWrw9ye8SNr1XwuXMJW78WXa6dL5KWQQXLlrimSf7/ubH/8OivcPVzX7dtkBdVFB7sDt7mXYt5e95/H3kK1Qt2ZpCqCDGjRunnidOnFio5cUa9Nprr+Gxxx5D79691bxJkyahcuXKmDFjBvr27QsjusaUhCeEELPh59pl9BghTWw8MHORcoeJJUhE0IPfxiG1Z5eoew/EbdTn1puxePES3PNCGkY2OItajYsHvd1EW1k0KNerwIKK8xfMxTN3Pe6ZlmOVmZmJtSuXK3eiWNKW/2PDpKw/UKthMXw4oBaqlgL2nwJ+2rkR036+F2WrGz/g2jRCKFB27NiBAwcOoEuXLp55KSkpaNu2LVauXGksIUTXGCHEinWETGDhFrEhgdESE6QhIkjmRxuJnVmwcLGKVVq+fDlcZ124smR7j6Vq65YtaHHhhfi4D9D3YmDBRqD3ROCDW4B/fQlsGQ3UKJOzvT0ngAbPATNnfIdKFzf3+5k2nXit0uQM3l/SDMnx0p4DOHpmj+rVdut/GsOeCPwA4FxSIm6xu9cR592e7HXbXphjgYpHCYwbtBZPdXOhZ+Ocz5rzN/DYPCjjRL1aujcijGWFkIggQSxAemRae88f6enp6qFx8uRJRDZ93vgXDkIIsYJrLFztMCJVobpxo+bo1rkbHvxmEZDlQM0yQFYGcDjN/fzjVm+X3w9b3PMb1M/2sfkhwV7S8zqpeBxciMO57OlyKe5nGbECafTRpvrdaFb7Uzz0/iLYrsuxvD38bRwu69AFrRp3QzSJqhAaPXo0nn/++XyX+fvvv9G4ceSU4rPPPutxw0UML9cYhRAhxISY0DUWrnYY0bRoiXHmmcU2tKzmwgMz3MNLIC6/EokVUerMldh1ZjEql7YhTvcTZjjcwdgpxYBi2eohywn8tTEdzfYcwrWVz3uWnfUX8J+5wNxZS9CicjtMnpJqWMtbVIXQiBEjMGTIkHyXqVvXJ5y/kFSpUkU9Hzx4EFWrVvXMl+mWLVWEll/GjBmD4cOHe1mEatasici5xgghxHyY1TVmdnwtWhUrVsQTYx9TwcwiigbpdEZhhUeryv9Gv0bjvcoKCJPXAv/3OVCmeBzG6yw7E74EiiXYEHe9K5e1p0Wjdoa3vEVVCMkPJo9wIFliIoYWL17sET4ialavXo177703z/WSkpLUI5LQNUYIMT/mqyNkJfQWLb3giI+PR1ZWVkDCo2E+QeSdO3dEQkKCl2VH2oAIg6YuKVB0GdHyZpoYoV27dqm0PXmW4lBST0iQH7dkSbdPU1xo4tq64YYblEn2oYcewtNPP60OupY+X61aNVx//fUwFPqiVXSNEUJMiL9isGZyjVmNYAXH5HyCyMW648+yY0Rrj6WE0NixY1U9II2LL75YPS9duhSdOnVSrzdt2oS0tDTPMqNGjcKZM2dw1113qYKKV1xxBebNm2ewGkLsNUYIsao9iDd2ZqVsAa4sf0LLiNYeSwkhqR9UUA0hr3o82XcjTz75pHoYGabPE0LMjzmzxkj+mFXcBALluhFg1hghxOTQNUbMCkddA0CLECHE7Pi/cvF6RowPhZABYNYYIcT8+LEI8XpGTADPUiPAXmOEECvWEeL1jJgACiEDQNcYIcTs+Bc9vJ4R40MhZAD02W40JRNCzAldY8ScmCZ93mps3rwZ27ZtU7UZEivqhBBNyYQQE0LXGDErFEIRRqpjDxrYX/WB0bhjeCe0HaBN8cJBCDEhdI0Rk0IhFGFEBK1asQgfTqqNCmXsOHIa2J65X3r+qvdpSiaEmBE2XSVmhUIowu4wsQRJR9/MRmVwMD5Oza+tW8Zu409CCDEf/kQPXWPEDFCuRxCJCRI61PX/vt1RArXLdIjsThFCSCiga4yYFJofIki9evXU84rtwC2r/4Ir+xox/XfggZnAqu9/Q+mkmtHdSUIIKQJ0jRGzQiEUQRo2bIjUnt3xwMxFcLky0bEesHwb8NC3cWjfoQsaNWwS7V0khJAiQdcYMSsUQhFm8pSpGDigHwZNzckaS+3ZRc0nhBDz4it6KIKIOaAQijBly5bF7DnzsGXLFmzdulXVEWrQoEG0d4sQQoLC1/pDtxgxCxRCUULEDwUQIcQ60AJEzAklOyGEkKDxtQDZbBxeiDngmUoIISRo6BojZoVnKiGEkBBA1xgxJxRChBBCgoauMWJWeKYSQggJuUGIrjFiFnimEkIICRoKH2JWeOYSQggJGrrGiFnhmUoIISR4cmWNMXiamAMKIUIIIUGTW/hQCBFzQCFECCEk5EKIrjFiFnimEkIICR4f4UPXGDELFEKEEEKChq4xYlYohAghhAQNXWPErPBMJYQQEjx0jRGTQiFECCEkaHLLHgohYg4ohAghhAQNCyoSs8IzlRBCSBiGE1qEiDmgECKEEBLqwtKMESKmgUKIEEJICPB1jVEIEXNAIUQIISRocluAOLwQc8AzlRBCSND4WoDoGiNmgUKIEEJICKAQIuaEQogQQkjI0+d9CywSYlR4phJCCAkausaIWaEQIoQQEgIohIg5oRAihBASNHSNEbPCM5UQQkgIoEWImBPTCKFnnnkG7du3R/HixVGmTJlCrTNkyBDlt9Y/evToEfZ9JYSQWIMxQsSsxMMkZGRk4JZbbkG7du3w4YcfFno9ET4ff/yxZzopKSlMe0gIIbELXWPErJhGCI0bN049T5w4MaD1RPhUqVIlTHtFCCHEDS1CxJxYXrIvW7YMlSpVQqNGjXDvvffi6NGj+S6fnp6OkydPej0IIYTkD11jxKxYWgiJW2zSpElYvHgxnn/+eSxfvhw9e/aEw+HIc51nn30WKSkpnkfNmjUjus+EEGJOfNvPW3p4IRYiqmfq6NGjcwUz+z42btxY5O337dsX1113HVq0aIHrr78es2bNwpo1a5SVKC/GjBmDtLQ0z2P37t1F/nxCCInVGCFahIhZiGqM0IgRI1RmV37UrVs3ZJ8n26pQoQK2bt2Kzp075xlTxIBqQggJzjWWy0JEiEGJqhCqWLGiekSKPXv2qBihqlWrRuwzCSEkNvCJEaJrjJgE05ypu3btwvr169WzxPjIa3mcPn3as0zjxo0xffp09Vrmjxw5EqtWrcLOnTtVnFDv3r1Rv359dO/ePYrfhBBCrAddY8SsmCZ9fuzYsfjkk0880xdffLF6Xrp0KTp16qReb9q0ScX1CHFxcfj999/VOidOnEC1atXQrVs3PPXUU3R9EUJIiMnlGaMQIibBNEJI6gcVVEPI5XJ5XhcrVgzz58+PwJ4RQgjxdTDQNUbMAs9UQgghQePrCqNrjJgFCiFCCCFBw6wxYlYohAghhITBNUYhRMwBhRAhhJAwuMY4vBBzwDOVEEJI0PhagM6cORu1fSEkECiECCGEBM2xYye8ppcuXYZeqT1w/PjxqO0TIYWBQogQQkjQ3DZ4oNd0q2ourFqxCAMH9IvaPhFSGCiECCGEBMXmzZsxZ84Cr3k1UoDx1zkwZ+58bNmyJWr7RkhBUAgRQggJim3btqnnsodPeeZVPXEKHeu5X0uja0KMimkqSxNCCDEm9eq5Fc/5KVvR46pSSMrMQsVTZzHFrY9Uj0dCjAotQoQQQoKiYcOGSO3ZHQ9+Y8fyhSeRvvsspqwFHvw2Ts1v0KBBtHeRkDyhRYgQQkjQTJ4yVQVGD5qa0+MxtWcXNZ8QI0MhRAghJGjKli2L2XPmqcBoiQkSdxgtQcQMUAgRQggJGSJ+KICImWCMECGEEEJiFgohQgghhMQsFEKEEEIIiVkohAghhBASs1AIEUIIISRmoRAihBBCSMxCIUQIIYSQmIVCiBBCCCExC4UQIYQQQmIWCiFCCCGExCxssVEALpdLPZ88eTLau0IIIYSQQqKN29o4nhcUQgVw6tQp9VyzZs1o7wohhBBCijCOp6Sk5Pm+zVWQVIpxnE4n9u3bh1KlSsFms4VUqYq42r17N0qXLh2y7ZLc8FhHBh7nyMFjHRl4nM19nEXeiAiqVq0a7Pa8I4FoESoAOXg1atQI2/blR+c/WGTgsY4MPM6Rg8c6MvA4m/c452cJ0mCwNCGEEEJiFgohQgghhMQsFEJRIikpCU888YR6JuGFxzoy8DhHDh7ryMDjHBvHmcHShBBCCIlZaBEihBBCSMxCIUQIIYSQmIVCiBBCCCExC4UQIYQQQmIWCqEo8eabb6JOnTpITk5G27Zt8fPPP0d7lyzHihUrcO2116qqolIVfMaMGdHeJUvy7LPP4pJLLlHV1ytVqoTrr78emzZtivZuWY63334bF154oafoXLt27TB37txo75blee6559T146GHHor2rliO//73v+rY6h+NGzeO+H5QCEWBL774AsOHD1fpguvWrcNFF12E7t2749ChQ9HeNUtx5swZdWxFdJLwsXz5ctx3331YtWoVFi5ciMzMTHTr1k0dfxI6pMK9DMpr167FL7/8gquvvhq9e/fGn3/+Ge1dsyxr1qzBu+++qwQoCQ/NmjXD/v37PY8ffvgBkYbp81FALEByB/3GG294+plJn5X7778fo0ePjvbuWRK505g+fbqyVpDwcvjwYWUZEoHUoUOHaO+OpSlXrhxefPFF3HHHHdHeFctx+vRptGrVCm+99RaefvpptGzZEq+99lq0d8tyFqEZM2Zg/fr1Ud0PWoQiTEZGhrqj69Kli1c/M5leuXJlVPeNkFCQlpbmGaRJeHA4HPj888+V1U1cZCT0iJWzV69eXtdqEnq2bNmiwhfq1q2LAQMGYNeuXYg0bLoaYY4cOaIuYpUrV/aaL9MbN26M2n4REgrEuimxFJdffjmaN28e7d2xHBs2bFDC5/z58yhZsqSycjZt2jTau2U5RGRK2IK4xkh4vSMTJ05Eo0aNlFts3LhxuPLKK/HHH3+omMNIQSFECAnpXbRcxKLh548FZMAQN4JY3b766ivcdtttygVJMRQ6du/ejQcffFDFu0kyCwkfPXv29LyWOCwRRrVr18a0adMi6u6lEIowFSpUQFxcHA4ePOg1X6arVKkStf0iJFiGDRuGWbNmqWw9CewloScxMRH169dXr1u3bq0sFuPHj1cBvSQ0SOiCJK5IfJCGWPHlvJa4zvT0dHUNJ6GnTJkyaNiwIbZu3YpIwhihKFzI5AK2ePFiL3eCTNPXT8yI5FuICBI3zZIlS3DBBRdEe5diBrl2yMBMQkfnzp2VC1Isb9qjTZs2Kn5FXlMEhTdAfdu2bahatSoiCS1CUUBS58WkLf9cl156qcpEkKDHoUOHRnvXLPdPpb+z2LFjh7qQSRBvrVq1orpvVnOHffbZZ5g5c6by6x84cEDNT0lJQbFixaK9e5ZhzJgxypUg5+6pU6fUMV+2bBnmz58f7V2zFHIO+8a3lShRAuXLl2fcW4h55JFHVK03cYft27dPlZQRodmvXz9EEgqhKNCnTx+VYjx27Fg1aEha5rx583IFUJPgkForV111lZcAFUSESoAeCV2hP6FTp05e8z/++GMMGTIkSntlPcRdM3jwYBVUKiJTYipEBHXt2jXau0ZIkdizZ48SPUePHkXFihVxxRVXqHpk8jqSsI4QIYQQQmIWxggRQgghJGahECKEEEJIzEIhRAghhJCYhUKIEEIIITELhRAhhBBCYhYKIUIIIYTELBRChBBCCIlZKIQIIZZFijw+9NBD0d4NQoiBoRAihBBAtauw2Ww4ceJEtHeFEBJBKIQIIYQQErNQCBFCLIE0LpZeXCVLllTdq19++WWv9z/99FPV6FiaalapUgX9+/dX/buEnTt3evrSlS1bVlmGtD5p0gdQeiCVKVNGNd685pprVIdsQog1oBAihFiCkSNHYvny5Zg5cyYWLFigXF3r1q3zvJ+ZmYmnnnoKv/32G2bMmKHEjyZ2atasia+//lq93rRpk2psOn78eI/Akoa90sR38eLFsNvtuOGGG+B0OqP0TQkhoYRNVwkhpuf06dPKWjN58mTccsstat6xY8dQo0YN3HXXXXjttddyrSPC5pJLLsGpU6eUFUmEk1iFjh8/rqw/eXHkyBHVHXvDhg1o3rx5WL8XIST80CJECDE94qrKyMhA27ZtPfPKlSuHRo0aeabXrl2La6+9FrVq1VLusY4dO6r5u3btynfbW7ZsQb9+/VC3bl2ULl0aderUKdR6hBBzQCFECLE84t7q3r27EjJTpkzBmjVrMH36dPWeCKj8EPEk1qX3338fq1evVo/CrEcIMQcUQoQQ01OvXj0kJCR4RIogLq7Nmzer1xs3bsTRo0fx3HPP4corr0Tjxo09gdIaiYmJ6tnhcHjmyToSM/TYY4+hc+fOaNKkidouIcQ6UAgRQkyPxPjccccdKmB6yZIl+OOPP1QgtAQ2C+IOE6Hz+uuvY/v27fj2229V4LSe2rVrq2yxWbNm4fDhwyruSDLIJPbovffew9atW9W2JXCaEGIdKIQIIZbgxRdfVNYecWV16dJFpby3bt1avSfBzRMnTsSXX36Jpk2bKsvQSy+95LV+9erVMW7cOIwePRqVK1fGsGHDlJD6/PPPVXyRBEY//PDD6nMIIdaBWWOEEEIIiVloESKEEEJIzEIhRAghhJCYhUKIEEIIITELhRAhhBBCYhYKIUIIIYTELBRChBBCCIlZKIQIIYQQErNQCBFCCCEkZqEQIoQQQkjMQiFECCGEkJiFQogQQgghMQuFECGEEEIQq/w/Ee8vbb6hFksAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Fit regression model\n",
    "regr_1 = DecisionTreeRegressor(max_depth=2)\n",
    "regr_2 = DecisionTreeRegressor(max_depth=5)\n",
    "regr_1.fit(X, y)\n",
    "regr_2.fit(X, y)\n",
    "\n",
    "# Predict\n",
    "X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]\n",
    "y_1 = regr_1.predict(X_test)\n",
    "y_2 = regr_2.predict(X_test)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure()\n",
    "plt.scatter(X, y, s=20, edgecolor=\"black\", c=\"darkorange\", label=\"data\")\n",
    "plt.plot(X_test, y_1, color=\"cornflowerblue\", label=\"max_depth=2\", linewidth=2)\n",
    "plt.plot(X_test, y_2, color=\"yellowgreen\", label=\"max_depth=5\", linewidth=2)\n",
    "plt.xlabel(\"data\")\n",
    "plt.ylabel(\"target\")\n",
    "plt.title(\"Decision Tree Regression\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scikit-learn 的决策树参数"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "DecisionTreeClassifier(criterion=\"gini\",\n",
    "                 splitter=\"best\",\n",
    "                 max_depth=None,\n",
    "                 min_samples_split=2,\n",
    "                 min_samples_leaf=1,\n",
    "                 min_weight_fraction_leaf=0.,\n",
    "                 max_features=None,\n",
    "                 random_state=None,\n",
    "                 max_leaf_nodes=None,\n",
    "                 min_impurity_decrease=0.,\n",
    "                 min_impurity_split=None,\n",
    "                 class_weight=None,\n",
    "                 presort=False)\n",
    "\n",
    "参数含义：\n",
    "1.criterion:string, optional (default=\"gini\")\n",
    "            (1).criterion='gini',分裂节点时评价准则是Gini指数。\n",
    "            (2).criterion='entropy',分裂节点时的评价指标是信息增益。\n",
    "2.max_depth:int or None, optional (default=None)。指定树的最大深度。\n",
    "            如果为None，表示树的深度不限。直到所有的叶子节点都是纯净的，即叶子节点\n",
    "            中所有的样本点都属于同一个类别。或者每个叶子节点包含的样本数小于min_samples_split。\n",
    "3.splitter:string, optional (default=\"best\")。指定分裂节点时的策略。\n",
    "           (1).splitter='best',表示选择最优的分裂策略。\n",
    "           (2).splitter='random',表示选择最好的随机切分策略。\n",
    "4.min_samples_split:int, float, optional (default=2)。表示分裂一个内部节点需要的做少样本数。\n",
    "           (1).如果为整数，则min_samples_split就是最少样本数。\n",
    "           (2).如果为浮点数(0到1之间)，则每次分裂最少样本数为ceil(min_samples_split * n_samples)\n",
    "5.min_samples_leaf: int, float, optional (default=1)。指定每个叶子节点需要的最少样本数。\n",
    "           (1).如果为整数，则min_samples_split就是最少样本数。\n",
    "           (2).如果为浮点数(0到1之间)，则每个叶子节点最少样本数为ceil(min_samples_leaf * n_samples)\n",
    "6.min_weight_fraction_leaf:float, optional (default=0.)\n",
    "           指定叶子节点中样本的最小权重。\n",
    "7.max_features:int, float, string or None, optional (default=None).\n",
    "           搜寻最佳划分的时候考虑的特征数量。\n",
    "           (1).如果为整数，每次分裂只考虑max_features个特征。\n",
    "           (2).如果为浮点数(0到1之间)，每次切分只考虑int(max_features * n_features)个特征。\n",
    "           (3).如果为'auto'或者'sqrt',则每次切分只考虑sqrt(n_features)个特征\n",
    "           (4).如果为'log2',则每次切分只考虑log2(n_features)个特征。\n",
    "           (5).如果为None,则每次切分考虑n_features个特征。\n",
    "           (6).如果已经考虑了max_features个特征，但还是没有找到一个有效的切分，那么还会继续寻找\n",
    "           下一个特征，直到找到一个有效的切分为止。\n",
    "8.random_state:int, RandomState instance or None, optional (default=None)\n",
    "           (1).如果为整数，则它指定了随机数生成器的种子。\n",
    "           (2).如果为RandomState实例，则指定了随机数生成器。\n",
    "           (3).如果为None，则使用默认的随机数生成器。\n",
    "9.max_leaf_nodes: int or None, optional (default=None)。指定了叶子节点的最大数量。\n",
    "           (1).如果为None,叶子节点数量不限。\n",
    "           (2).如果为整数，则max_depth被忽略。\n",
    "10.min_impurity_decrease:float, optional (default=0.)\n",
    "         如果节点的分裂导致不纯度的减少(分裂后样本比分裂前更加纯净)大于或等于min_impurity_decrease，则分裂该节点。\n",
    "         加权不纯度的减少量计算公式为：\n",
    "         min_impurity_decrease=N_t / N * (impurity - N_t_R / N_t * right_impurity\n",
    "                            - N_t_L / N_t * left_impurity)\n",
    "         其中N是样本的总数，N_t是当前节点的样本数，N_t_L是分裂后左子节点的样本数，\n",
    "         N_t_R是分裂后右子节点的样本数。impurity指当前节点的基尼指数，right_impurity指\n",
    "         分裂后右子节点的基尼指数。left_impurity指分裂后左子节点的基尼指数。\n",
    "11.min_impurity_split:float\n",
    "         树生长过程中早停止的阈值。如果当前节点的不纯度高于阈值，节点将分裂，否则它是叶子节点。\n",
    "         这个参数已经被弃用。用min_impurity_decrease代替了min_impurity_split。\n",
    "12.class_weight:dict, list of dicts, \"balanced\" or None, default=None\n",
    "         类别权重的形式为{class_label: weight}\n",
    "         (1).如果没有给出每个类别的权重，则每个类别的权重都为1。\n",
    "         (2).如果class_weight='balanced'，则分类的权重与样本中每个类别出现的频率成反比。\n",
    "         计算公式为：n_samples / (n_classes * np.bincount(y))\n",
    "         (3).如果sample_weight提供了样本权重(由fit方法提供)，则这些权重都会乘以sample_weight。\n",
    "13.presort:bool, optional (default=False)\n",
    "        指定是否需要提前排序数据从而加速训练中寻找最优切分的过程。设置为True时，对于大数据集\n",
    "        会减慢总体的训练过程；但是对于一个小数据集或者设定了最大深度的情况下，会加速训练过程。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树调参"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入库\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn import datasets\n",
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150, 4) (150,)\n"
     ]
    }
   ],
   "source": [
    "# 导入数据集\n",
    "X = datasets.load_iris()  # 以全部字典形式返回,有data,target,target_names三个键\n",
    "data = X.data\n",
    "target = X.target\n",
    "name = X.target_names\n",
    "x, y = datasets.load_iris(return_X_y=True)  # 能一次性取前2个\n",
    "print(x.shape, y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 数据分为训练集和测试集\n",
    "x_train, x_test, y_train, y_test = train_test_split(x,\n",
    "                                                    y,\n",
    "                                                    test_size=0.2,\n",
    "                                                    random_state=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最优分类器: {'criterion': 'gini', 'max_depth': 30, 'min_impurity_decrease': 0.2, 'min_samples_leaf': 2} 最优分数: 0.9416666666666665\n"
     ]
    }
   ],
   "source": [
    "# 用GridSearchCV寻找最优参数（字典）\n",
    "param = {\n",
    "    'criterion': ['gini'],\n",
    "    'max_depth': [30, 50, 60, 100],\n",
    "    'min_samples_leaf': [2, 3, 5, 10],\n",
    "    'min_impurity_decrease': [0.1, 0.2, 0.5]\n",
    "}\n",
    "grid = GridSearchCV(DecisionTreeClassifier(), param_grid=param, cv=6)\n",
    "grid.fit(x_train, y_train)\n",
    "print('最优分类器:', grid.best_params_, '最优分数:', grid.best_score_)  # 得到最优的参数和分值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 参考\n",
    "\n",
    "- https://github.com/fengdu78/lihang-code\n",
    "\n",
    "- 李航. 统计学习方法[M]. 北京: 清华大学出版社,2019.\n",
    "\n",
    "- https://scikit-learn.org"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
